Developer CD Series 1992 June: ROMin Holiday/ADC Developer CD (1992-06) (''ROMin Holiday'')_iso/Developer Connection - 06-1992.iso/Developer Essentials/Technical Docs/Inside Macintosh/Inside Macintosh Vol. VI/Browser/Support files/Interfaces/ResourcesHelp data

Text File | 1991-04-05 | 346.1 KB | 7,988 lines | [TEXT/MPS ]

æKY CopyrightNotice
æC  Copyright Apple Computer, Inc. 1985-1991, All rights reserved.
411 - Resources Help - MPW 3.2 Final Release.
Thursday, April 4, 1991 8:44:57 AM


æKY Help
ResourcesHelp
æKL AboutResourcesHelp
BalloonTypes.r
Cmdo.r
CTBTypes.r
InstallerTypes.r
MPWTypes.r
Pict.r
SIOW.h
siow.r
SysTypes.r
Types.r


æKY AboutResourcesHelp
æC

Version 1.0 Final  -- Shipped with MPW 3.2 Final

This version contains the new and updated files to support System 7.0.

æKY BalloonTypes.r
æKL
hdlg
HelpMgrVersion
hfdr
hmAbsoluteCoords
HMCompareItemID
hmDefaultOptions
hmMatchInTitle
HMNamedResourceID
hmnu
HMPictItemID
hmSaveBitsNoWindow
hmSaveBitsWindow
HMSkipItemID
HMStringItemID
HMStringResItemID
HMSTRResItemID
HMTEResItemID
HMTrackCntlID
hmUseSubID
hovr
hrct
hwin
kBalloonWDEFID
kHMHelpID
kHMHelpMenuID

æKY HelpMgrVersion
æFr BalloonTypes.r
æT #define
æD #define HelpMgrVersion                2       /* version of Help Manager */
æC

æKY kHMHelpID
æFr BalloonTypes.r
æT #define
æD #define kHMHelpID                 -5696       /* resource ID of Help Manager resources */
æC

æKY kHMHelpMenuID
æFr BalloonTypes.r
æT #define
æD #define kHMHelpMenuID            -16490       /* resource ID of Help Manager Menu resource */
æC

æKY kBalloonWDEFID
æFr BalloonTypes.r
æT #define
æD #define kBalloonWDEFID              126          /* resource ID of Balloon WDEF procedure */
æC

æKY hmDefaultOptions
æFr BalloonTypes.r
æT #define
æD #define hmDefaultOptions              0       /* default options for help manager resources */
æC

æKY hmUseSubID
æFr BalloonTypes.r
æT #define
æD #define hmUseSubID                    1       /* treat resID's in resources */
æC

æKY hmAbsoluteCoords
æFr BalloonTypes.r
æT #define
æD #define hmAbsoluteCoords              2       /* ignore window port origin and treat rectangles as absolute coords (local to window) */
æC

æKY hmSaveBitsNoWindow
æFr BalloonTypes.r
æT #define
æD #define hmSaveBitsNoWindow            4       /* don't create a window, just blast bits on screen. No update event is generated */
æC

æKY hmSaveBitsWindow
æFr BalloonTypes.r
æT #define
æD #define hmSaveBitsWindow              8       /* create a window, but restore bits behind window when window goes away & generate update event */
æC

æKY hmMatchInTitle
æFr BalloonTypes.r
æT #define
æD #define hmMatchInTitle               16       /* for hwin resources, match string anywhere in window title string */
æC

æKY HMStringItemID
æFr BalloonTypes.r
æT #define
æD #define HMStringItemID                1       /* pstring is used in help message */
æC

æKY HMPictItemID
æFr BalloonTypes.r
æT #define
æD #define HMPictItemID                  2       /* 'PICT' resource ID is used in help message */
æC

æKY HMStringResItemID
æFr BalloonTypes.r
æT #define
æD #define HMStringResItemID             3       /* 'STR#' resource ID and index is used in help message */
æC

æKY HMTEResItemID
æFr BalloonTypes.r
æT #define
æD #define HMTEResItemID                 6       /* Styled Text Edit resources are used in help message */
æC

æKY HMSTRResItemID
æFr BalloonTypes.r
æT #define
æD #define HMSTRResItemID                7       /* 'STR ' resource ID is used in help message */
æC

æKY HMSkipItemID
æFr BalloonTypes.r
æT #define
æD #define HMSkipItemID                256          /* don't display a balloon */
æC

æKY HMCompareItemID
æFr BalloonTypes.r
æT #define
æD #define HMCompareItemID             512       /* for hmnu resources, compare menu item to string and use help msg if match */
æC

æKY HMNamedResourceID
æFr BalloonTypes.r
æT #define
æD #define HMNamedResourceID          1024       /* for hmnu resources, use menu item as call to GetNamedResource() to fetch resource */
æC

æKY HMTrackCntlID
æFr BalloonTypes.r
æT #define
æD #define HMTrackCntlID              2048       /* not yet implemented, reserved */
æC

æKY hmnu
æFr BalloonTypes.r
æT
æD
/*----------------------------hmnu • Help Mgr Menu Balloon Template----------------------------*/
type 'hmnu' {
        integer;                                    /* Help Version */
        longint;                                    /* Options */
        integer;                                    /* Balloon ProcID */
        integer;                                    /* Balloon variant */
        integer = $$CountOf(HMenuArray);            /* Count of menu items (below) */

        switch {            /* Special Message for missing array items */
                case HMStringItem:
hmnuMissStringBeg:      integer = (hmnuMissStringEnd - hmnuMissStringBeg) / 8;
                        key int = HMStringItemID;
                        pstring;            /* missing HMenuArray items (Enabled)  */
                        pstring;            /* missing HMenuArray items (Disabled)  */
                        pstring;            /* missing HMenuArray items (checked) */
                        pstring;            /* missing HMenuArray items (other)  */
                        align word;         /* always word align the code for the pstring */
hmnuMissStringEnd:
                case HMPictItem:
hmnuMissPictBeg:        integer = (hmnuMissPictEnd - hmnuMissPictBeg) / 8;
                        key int = HMPictItemID;
                        integer;            /* use for missing HMenuArray items  */
                        integer;            /* use for missing HMenuArray items  */
                        integer;            /* use for missing HMenuArray items  */
                        integer;            /* use for missing HMenuArray items  */
hmnuMissPictEnd:
                case HMStringResItem:
hmnuMissStringResBeg:   integer = (hmnuMissStringResEnd - hmnuMissStringResBeg) / 8;
                        key int = HMStringResItemID;
                        integer; integer;   /* Miss or 0 HMenuArray STR# res ID, index # */
                        integer; integer;   /* Miss or 0 HMenuArray STR# res ID, index # */
                        integer; integer;   /* Miss or 0 HMenuArray STR# res ID, index # */
                        integer; integer;   /* Miss or 0 HMenuArray STR# res ID, index # */
hmnuMissStringResEnd:
                case HMTEResItem:
hmnuMissTEResBeg:       integer = (hmnuMissTEResEnd - hmnuMissTEResBeg) / 8;
                        key int = HMTEResItemID;
                        integer;            /* use for missing HMenuArray items */
                        integer;            /* use for missing HMenuArray items */
                        integer;            /* use for missing HMenuArray items */
                        integer;            /* use for missing HMenuArray items */
hmnuMissTEResEnd:
                case HMSTRResItem:
hmnuMissSTRResBeg:      integer = (hmnuMissSTRResEnd - hmnuMissSTRResBeg) / 8;
                        key int = HMSTRResItemID;
                        integer;            /* use for missing HMenuArray items */
                        integer;            /* use for missing HMenuArray items */
                        integer;            /* use for missing HMenuArray items */
                        integer;            /* use for missing HMenuArray items */
hmnuMissSTRResEnd:
                case HMSkipItem:
hmnuMissSkipBeg:        integer = (hmnuMissSkipEnd - hmnuMissSkipBeg) / 8;
                        key int = HMSkipItemID; /* use when there is no missing msg */
hmnuMissSkipEnd:
            };

        array HMenuArray {
                switch {
                    case HMStringItem:
hmnuStringBeg:          integer = (hmnuStringEnd[$$ArrayIndex(HMenuArray)] - hmnuStringBeg[$$ArrayIndex(HMenuArray)]) / 8;
                        key int = HMStringItemID;
                        pstring;            /* Enabled menu message string  */
                        pstring;            /* Disabled menu message string */
                        pstring;            /* Checked menu message string */
                        pstring;            /* other menu message string */
                        align word;
hmnuStringEnd:
                    case HMPictItem:
hmnuPictBeg:            integer = (hmnuPictEnd[$$ArrayIndex(HMenuArray)] - hmnuPictBeg[$$ArrayIndex(HMenuArray)]) / 8;
                        key int = HMPictItemID;
                        integer;            /* Enabled menu message pict ID  */
                        integer;            /* Disabled menu message pict ID */
                        integer;            /* Checked menu message pict ID */
                        integer;            /* other menu message pict ID */
hmnuPictEnd:
                    case HMStringResItem:
hmnuStringResBeg:       integer = (hmnuStringResEnd[$$ArrayIndex(HMenuArray)] - hmnuStringResBeg[$$ArrayIndex(HMenuArray)]) / 8;
                        key int = HMStringResItemID;
                        integer; integer;   /* Enabled STR# res ID, index # */
                        integer; integer;   /* Disabled STR# res ID, index # */
                        integer; integer;   /* Checked menu message STR# res ID, index # */
                        integer; integer;   /* other menu message STR# res ID, index # */
hmnuStringResEnd:
                    case HMTEResItem:
hmnuTEResBeg:           integer = (hmnuTEResEnd[$$ArrayIndex(HMenuArray)] - hmnuTEResBeg[$$ArrayIndex(HMenuArray)]) / 8;
                        key int = HMTEResItemID;
                        integer;            /* Enabled menu message TERes ID */
                        integer;            /* Disabled menu message TERes ID */
                        integer;            /* Checked message TERes ID */
                        integer;            /* other menu message TERes ID */
hmnuTEResEnd:
                    case HMSTRResItem:
hmnuSTRResBeg:          integer = (hmnuSTRResEnd[$$ArrayIndex(HMenuArray)] - hmnuSTRResBeg[$$ArrayIndex(HMenuArray)]) / 8;
                        key int = HMSTRResItemID;
                        integer;            /* Enabled menu message STR ID */
                        integer;            /* Disabled menu message STR ID */
                        integer;            /* Checked message STR ID */
                        integer;            /* other menu message STR ID */
hmnuSTRResEnd:
                    case HMSkipItem:
hmnuSkipBeg:            integer = (hmnuSkipEnd[$$ArrayIndex(HMenuArray)] - hmnuSkipBeg[$$ArrayIndex(HMenuArray)]) / 8;
                        key int = HMSkipItemID;
hmnuSkipEnd:
                    case HMCompareItem:
hmnuCompareBeg:         integer = (hmnuCompareEnd[$$ArrayIndex(HMenuArray)] - hmnuCompareBeg[$$ArrayIndex(HMenuArray)]) / 8;
                        key int = HMCompareItemID;
                        pstring;            /* if itemstr matches, use this item, else goto next item */
                        align word;

                        switch {                    /* case the message type */

                            case HMStringItem:
                                key int = HMStringItemID;
                                pstring;            /* Enabled menu message string  */
                                pstring;            /* Disabled menu message string */
                                pstring;            /* Checked menu message string */
                                pstring;            /* other menu message string */
                                align word;

                            case HMPictItem:
                                key int = HMPictItemID;
                                integer;            /* Enabled menu message pict ID  */
                                integer;            /* Disabled menu message pict ID */
                                integer;            /* Checked menu message pict */
                                integer;            /* other menu message pict */

                            case HMStringResItem:
                                key int = HMStringResItemID;
                                integer; integer;   /* Enabled STR# res ID, index # */
                                integer; integer;   /* Disabled STR# res ID, index # */
                                integer; integer;   /* Checked menu message STR# res ID, index # */
                                integer; integer;   /* other menu message STR# res ID, index # */

                            case HMTEResItem:
                                key int = HMTEResItemID;
                                integer;            /* Enabled menu message TERes ID */
                                integer;            /* Disabled menu message TERes ID */
                                integer;            /* Checked menu message TERes ID */
                                integer;            /* other menu message TERes ID */

                            case HMSTRResItem:
                                key int = HMSTRResItemID;
                                integer;            /* Enabled menu message STR ID */
                                integer;            /* Disabled menu message STR ID */
                                integer;            /* Checked menu message STR ID */
                                integer;            /* other menu message STR ID */

                            case HMSkipItem:
                                key int = HMSkipItemID;
                        };
hmnuCompareEnd:
                    case HMNamedResourceItem:
hmnuNamedResBeg:        integer = (hmnuNamedResEnd[$$ArrayIndex(HMenuArray)] - hmnuNamedResBeg[$$ArrayIndex(HMenuArray)]) / 8;
                        key int = HMNamedResourceID;
                        literal longint;    /*  res type of resource to fetch, using item name  */
hmnuNamedResEnd:
                };
        };
};
æC

æKY hdlg
æFr BalloonTypes.r
æT
æD
/*----------------------------hdlg • Help Mgr Dialog Balloon Template--------------------------*/
type 'hdlg' {
        integer;                                    /* Help Version */
        integer;                                    /* item # (0-based) of first DITL item */
        longint;                                    /* Options  */
        integer;                                    /* Balloon ProcID */
        integer;                                    /* Balloon variant */

        integer = $$CountOf(HDialogArray);          /* Count of HDialogArray items  */

        switch {            /* Special Messages for missing array items */
                case HMStringItem:
hdlgMissStringBeg:      integer = (hdlgMissStringEnd - hdlgMissStringBeg) / 8;
                        key int = HMStringItemID;
                        point;                          /* tip          */
                        rect;                           /* hotRect      */
                        pstring;            /* use for missing HDialogArray items  */
                        pstring;            /* use for missing HDialogArray items  */
                        pstring;            /* use for missing HDialogArray items  */
                        pstring;            /* use for missing HDialogArray items  */
                        align word;         /* always word align the code for the pstring */
hdlgMissStringEnd:
                case HMPictItem:
hdlgMissPictBeg:        integer = (hdlgMissPictEnd - hdlgMissPictBeg) / 8;
                        key int = HMPictItemID;
                        point;                          /* tip          */
                        rect;                           /* hotRect      */
                        integer;            /* use for missing HDialogArray items  */
                        integer;            /* use for missing HDialogArray items  */
                        integer;            /* use for missing HDialogArray items  */
                        integer;            /* use for missing HDialogArray items  */
hdlgMissPictEnd:
                case HMStringResItem:
hdlgMissStringResBeg:   integer = (hdlgMissStringResEnd - hdlgMissStringResBeg) / 8;
                        key int = HMStringResItemID;
                        point;                          /* tip          */
                        rect;                           /* hotRect      */
                        integer; integer;   /* Miss or 0 HDialogArray STR# res ID, index # */
                        integer; integer;   /* Miss or 0 HDialogArray STR# res ID, index # */
                        integer; integer;   /* Miss or 0 HDialogArray STR# res ID, index # */
                        integer; integer;   /* Miss or 0 HDialogArray STR# res ID, index # */
hdlgMissStringResEnd:
                case HMTEResItem:
hdlgMissTEResBeg:       integer = (hdlgMissTEResEnd - hdlgMissTEResBeg) / 8;
                        key int = HMTEResItemID;
                        point;                          /* tip          */
                        rect;                           /* hotRect      */
                        integer;            /* use for missing HDialogArray items */
                        integer;            /* use for missing HDialogArray items */
                        integer;            /* use for missing HDialogArray items */
                        integer;            /* use for missing HDialogArray items */
hdlgMissTEResEnd:
                case HMSTRResItem:
hdlgMissSTRResBeg:      integer = (hdlgMissSTRResEnd - hdlgMissSTRResBeg) / 8;
                        key int = HMSTRResItemID;
                        point;                          /* tip          */
                        rect;                           /* hotRect      */
                        integer;            /* use for missing HDialogArray items */
                        integer;            /* use for missing HDialogArray items */
                        integer;            /* use for missing HDialogArray items */
                        integer;            /* use for missing HDialogArray items */
hdlgMissSTRResEnd:
                case HMSkipItem:
hdlgMissSkipBeg:        integer = (hdlgMissSkipEnd - hdlgMissSkipBeg) / 8;
                        key int = HMSkipItemID; /* use when there is no missing msg */
hdlgMissSkipEnd:
            };

        /* this is an array of records corresponding to dialog items in a dialog */
        array HDialogArray {
                switch {
                    case HMStringItem:
hdlgStringBeg:          integer = (hdlgStringEnd[$$ArrayIndex(HDialogArray)] - hdlgStringBeg[$$ArrayIndex(HDialogArray)]) / 8;
                        key int = HMStringItemID;       /* helpType     */
                        point;                          /* tip          */
                        rect;                           /* hotRect      */
                        pstring;        /* Enabled dialog item message string   */
                        pstring;        /* Disabled dialog item message string  */
                        pstring;        /* Checked dialog item message string   */
                        pstring;        /* other dialog item message string     */
                        align word;     /* always word align the code */
hdlgStringEnd:
                    case HMPictItem:
hdlgPictBeg:            integer = (hdlgPictEnd[$$ArrayIndex(HDialogArray)] - hdlgPictBeg[$$ArrayIndex(HDialogArray)]) / 8;
                        key int = HMPictItemID;         /* helpType     */
                        point;                          /* tip          */
                        rect;                           /* hotRect      */
                        integer;        /* Enabled dialog item message pict ID  */
                        integer;        /* Disabled dialog item message pict ID */
                        integer;        /* Checked dialog item message pict ID  */
                        integer;        /* other dialog item message pict ID    */
hdlgPictEnd:
                    case HMStringResItem:
hdlgStringResBeg:       integer = (hdlgStringResEnd[$$ArrayIndex(HDialogArray)] - hdlgStringResBeg[$$ArrayIndex(HDialogArray)]) / 8;
                        key int = HMStringResItemID;    /* helpType     */
                        point;                          /* tip          */
                        rect;                           /* hotRect      */
                        integer; integer;   /* Enabled STR# res ID, index #     */
                        integer; integer;   /* Disabled STR# res ID, index #    */
                        integer; integer;   /* Checked STR# res ID, index #     */
                        integer; integer;   /* other STR# res ID, index #       */
hdlgStringResEnd:
                    case HMTEResItem:
hdlgTEResBeg:           integer = (hdlgTEResEnd[$$ArrayIndex(HDialogArray)] - hdlgTEResBeg[$$ArrayIndex(HDialogArray)]) / 8;
                        key int = HMTEResItemID;        /* helpType     */
                        point;                          /* tip          */
                        rect;                           /* hotRect      */
                        integer;        /* Enabled dialog item message TERes ID */
                        integer;        /* Disabled item message TERes ID       */
                        integer;        /* Checked item message TERes ID        */
                        integer;        /* other item message TERes ID          */
hdlgTEResEnd:
                    case HMSTRResItem:
hdlgSTRResBeg:          integer = (hdlgSTRResEnd[$$ArrayIndex(HDialogArray)] - hdlgSTRResBeg[$$ArrayIndex(HDialogArray)]) / 8;
                        key int = HMSTRResItemID;       /* helpType     */
                        point;                          /* tip          */
                        rect;                           /* hotRect      */
                        integer;        /* Enabled dialog item message STR ID   */
                        integer;        /* Disabled dialog item message STR ID  */
                        integer;        /* Checked dialog item message STR ID   */
                        integer;        /* other dialog item message STR ID     */
hdlgSTRResEnd:
                    case HMSkipItem:
hdlgSkipBeg:            integer = (hdlgSkipEnd[$$ArrayIndex(HDialogArray)] - hdlgSkipBeg[$$ArrayIndex(HDialogArray)]) / 8;
                        key int = HMSkipItemID;
hdlgSkipEnd:
                };
        };
};
æC

æKY hwin
æFr BalloonTypes.r
æT
æD /*----------------------------hwin • Help Mgr Window Balloon Template--------------------------*/
type 'hwin' {
        integer;                                    /* Help Version */
        longint;                                    /* Options              */
        integer = $$CountOf(HWinArray);             /* Count                */
        array HWinArray {
                integer;            /* resource ID for help template        */
                literal longint;    /* res type of template (hdlg or hrct)  */
                integer;            /* len of comparison string             */
                pstring;            /* comparison string for window title   */
                align word;
        };
};
æC

æKY hrct
æFr BalloonTypes.r
æT
æD /*----------------------------hrct • Help Mgr Rectangle List Template-------------------------*/
type 'hrct' {
        integer;                                    /* Help Version         */
        longint;                                    /* Options              */
        integer;                                    /* Balloon ProcID       */
        integer;                                    /* Balloon Variant      */
        integer = $$CountOf(HRectArray);            /* Count of hrct Msgs   */

        array HRectArray {
                switch {
                    case HMStringItem:
hrctStringBeg:          integer = (hrctStringEnd[$$ArrayIndex(HRectArray)] - hrctStringBeg[$$ArrayIndex(HRectArray)]) / 8;
                        key int = HMStringItemID;   /* helpType         */
                        point;                      /* tip              */
                        rect;                       /* hotRect          */
                        pstring;                    /* STR255           */
                        align word;                 /* keep aligned     */
hrctStringEnd:
                    case HMPictItem:
hrctPictBeg:            integer = (hrctPictEnd[$$ArrayIndex(HRectArray)] - hrctPictBeg[$$ArrayIndex(HRectArray)]) / 8;
                        key int = HMPictItemID;     /* helpType         */
                        point;                      /* tip              */
                        rect;                       /* hotRect          */
                        integer;                    /* Picture Res ID   */
hrctPictEnd:
                    case HMStringResItem:
hrctStringResBeg:       integer = (hrctStringResEnd[$$ArrayIndex(HRectArray)] - hrctStringResBeg[$$ArrayIndex(HRectArray)]) / 8;
                        key int = HMStringResItemID;/* helpType         */
                        point;                      /* tip              */
                        rect;                       /* hotRect          */
                        integer; integer;           /* STR# ID, index # */
hrctStringResEnd:
                    case HMTEResItem:
hrctTEResBeg:           integer = (hrctTEResEnd[$$ArrayIndex(HRectArray)] - hrctTEResBeg[$$ArrayIndex(HRectArray)]) / 8;
                        key int = HMTEResItemID;    /* helpType         */
                        point;                      /* tip              */
                        rect;                       /* hotRect          */
                        integer;                    /* TextEdit res ID  */
hrctTEResEnd:
                    case HMSTRResItem:
hrctSTRResBeg:          integer = (hrctSTRResEnd[$$ArrayIndex(HRectArray)] - hrctSTRResBeg[$$ArrayIndex(HRectArray)]) / 8;
                        key int = HMSTRResItemID;   /* helpType         */
                        point;                      /* tip              */
                        rect;                       /* hotRect          */
                        integer;                    /* STR res ID       */
hrctSTRResEnd:
                    case HMSkipItem:
hrctSkipBeg:            integer = (hrctSkipEnd[$$ArrayIndex(HRectArray)] - hrctSkipBeg[$$ArrayIndex(HRectArray)]) / 8;
                        key int = HMSkipItemID;     /* skip item (leave a hole) */
                        point;                      /* tip options (keep same structure as other items) */
                        rect;                       /* skip this rect           */
hrctSkipEnd:
                    case HMTrackControlStringItem:
hrctTCStringBeg:        integer = (hrctTCStringEnd[$$ArrayIndex(HRectArray)] - hrctTCStringBeg[$$ArrayIndex(HRectArray)]) / 8;
                        key int = HMStringItemID+HMTrackCntlID;
                        point;                      /* tip              */
                        rect;                       /* hotRect          */
                        pstring;                    /* Enabled control message string       */
                        pstring;                    /* Disabled control message string      */
                        pstring;                    /* Checked control message string       */
                        pstring;                    /* other control message string         */
                        align word;                 /* keep aligned     */
hrctTCStringEnd:
                    case HMTrackControlPictItem:
hrctTCPictBeg:          integer = (hrctTCPictEnd[$$ArrayIndex(HRectArray)] - hrctTCPictBeg[$$ArrayIndex(HRectArray)]) / 8;
                        key int = HMPictItemID+HMTrackCntlID;
                        point;                      /* tip              */
                        rect;                       /* hotRect          */
                        integer;                    /* Enabled control message pict ID      */
                        integer;                    /* Disabled control message pict ID     */
                        integer;                    /* Checked control message pict ID      */
                        integer;                    /* other control message pict ID        */
hrctTCPictEnd:
                    case HMTrackControlStringResItem:
hrctTCStringResBeg:     integer = (hrctTCStringResEnd[$$ArrayIndex(HRectArray)] - hrctTCStringResBeg[$$ArrayIndex(HRectArray)]) / 8;
                        key int = HMStringResItemID+HMTrackCntlID;
                        point;                      /* tip              */
                        rect;                       /* hotRect          */
                        integer; integer;           /* Enabled STR# res ID, index #     */
                        integer; integer;           /* Disabled STR# res ID, index #    */
                        integer; integer;           /* Checked STR# res ID, index #     */
                        integer; integer;           /* other STR# res ID, index #       */
hrctTCStringResEnd:
                    case HMTrackControlTEResItem:
hrctTCTEResBeg:         integer = (hrctTCTEResEnd[$$ArrayIndex(HRectArray)] - hrctTCTEResBeg[$$ArrayIndex(HRectArray)]) / 8;
                        key int = HMTEResItemID+HMTrackCntlID;
                        point;                      /* tip              */
                        rect;                       /* hotRect          */
                        integer;                    /* Enabled TextEdit hdl spec ID     */
                        integer;                    /* Disabled TextEdit hdl spec ID    */
                        integer;                    /* Checked TextEdit hdl spec ID     */
                        integer;                    /* other TextEdit hdl spec ID       */
hrctTCTEResEnd:
                    case HMTrackControlSTRResItem:
hrctTCSTRResBeg:        integer = (hrctTCSTRResEnd[$$ArrayIndex(HRectArray)] - hrctTCSTRResBeg[$$ArrayIndex(HRectArray)]) / 8;
                        key int = HMSTRResItemID+HMTrackCntlID;
                        point;                      /* tip              */
                        rect;                       /* hotRect          */
                        integer;                    /* Enabled control message STR ID       */
                        integer;                    /* Disabled control message STR ID      */
                        integer;                    /* Checked control message STR ID       */
                        integer;                    /* other control message STR ID         */
hrctTCSTRResEnd:
                };
        };
};
æC

æKY hovr
æFr BalloonTypes.r
æT
æD /*----------------------------hovr • Help Mgr Override Resource Template-------------------------*/

type 'hovr' {
        integer;                                    /* Help Version */
        longint;                                    /* Options */
        integer;                                    /* Balloon ProcID */
        integer;                                    /* Balloon variant */
        integer = $$CountOf(HOverrideArray);        /* Count of array items (below) */

        switch {            /* Special Message for missing array items */
                case HMStringItem:
hovrMissStringBeg:      integer = (hovrMissStringEnd - hovrMissStringBeg) / 8;
                        key int = HMStringItemID;
                        pstring;                /* missing HOverrideArray item  */
                        align word;             /* always word align the code for the pstring */
hovrMissStringEnd:
                case HMPictItem:
hovrMissPictBeg:        integer = (hovrMissPictEnd - hovrMissPictBeg) / 8;
                        key int = HMPictItemID;
                        integer;                /* missing HOverrideArray item  */
hovrMissPictEnd:
                case HMStringResItem:
hovrMissStringResBeg:   integer = (hovrMissStringResEnd - hovrMissStringResBeg) / 8;
                        key int = HMStringResItemID;
                        integer; integer;       /* Miss or 0 HOverrideArray STR# res ID, index # */
hovrMissStringResEnd:
                case HMTEResItem:
hovrMissTEResBeg:       integer = (hovrMissTEResEnd - hovrMissTEResBeg) / 8;
                        key int = HMTEResItemID;
                        integer;                /* use for missing HOverrideArray items */
hovrMissTEResEnd:
                case HMSTRResItem:
hovrMissSTRResBeg:      integer = (hovrMissSTRResEnd - hovrMissSTRResBeg) / 8;
                        key int = HMSTRResItemID;
                        integer;                /* use for missing HOverrideArray items */
hovrMissSTRResEnd:
                case HMSkipItem:
hovrMissSkipBeg:        integer = (hovrMissSkipEnd - hovrMissSkipBeg) / 8;
                        key int = HMSkipItemID; /* use when there is no missing msg */
hovrMissSkipEnd:
            };

        array HOverrideArray {
                switch {
                    case HMStringItem:
hovrStringBeg:          integer = (hovrStringEnd[$$ArrayIndex(HOverrideArray)] - hovrStringBeg[$$ArrayIndex(HOverrideArray)]) / 8;
                        key int = HMStringItemID;
                        pstring;            /* message string  */
                        align word;
hovrStringEnd:
                    case HMPictItem:
hovrPictBeg:            integer = (hovrPictEnd[$$ArrayIndex(HOverrideArray)] - hovrPictBeg[$$ArrayIndex(HOverrideArray)]) / 8;
                        key int = HMPictItemID;
                        integer;            /* message pict ID  */
hovrPictEnd:
                    case HMStringResItem:
hovrStringResBeg:       integer = (hovrStringResEnd[$$ArrayIndex(HOverrideArray)] - hovrStringResBeg[$$ArrayIndex(HOverrideArray)]) / 8;
                        key int = HMStringResItemID;
                        integer; integer;   /* STR# res ID, index # */
hovrStringResEnd:
                    case HMTEResItem:
hovrTEResBeg:           integer = (hovrTEResEnd[$$ArrayIndex(HOverrideArray)] - hovrTEResBeg[$$ArrayIndex(HOverrideArray)]) / 8;
                        key int = HMTEResItemID;
                        integer;            /* message TERes ID */
hovrTEResEnd:
                    case HMSTRResItem:
hovrSTRResBeg:          integer = (hovrSTRResEnd[$$ArrayIndex(HOverrideArray)] - hovrSTRResBeg[$$ArrayIndex(HOverrideArray)]) / 8;
                        key int = HMSTRResItemID;
                        integer;            /* message STR ID */
hovrSTRResEnd:
                    case HMSkipItem:
hovrSkipBeg:            integer = (hovrSkipEnd[$$ArrayIndex(HOverrideArray)] - hovrSkipBeg[$$ArrayIndex(HOverrideArray)]) / 8;
                        key int = HMSkipItemID;
hovrSkipEnd:
                };
        };
};
æC

æKY hfdr
æFr BalloonTypes.r
æT
æD
/*----------------------------hfdr • Help Mgr Finder Application Balloon Template-------------------------*/
type 'hfdr' {
        integer;                                    /* Help Version         */
        longint;                                    /* Options              */
        integer;                                    /* Balloon ProcID       */
        integer;                                    /* Balloon Variant      */
        integer = $$CountOf(HFdrArray);             /* Count of hfdr Msgs   */

        array HFdrArray {
                switch {
                    case HMStringItem:
hfdrStringBeg:          integer = (hfdrStringEnd[$$ArrayIndex(HFdrArray)] - hfdrStringBeg[$$ArrayIndex(HFdrArray)]) / 8;
                        key int = HMStringItemID;   /* helpType         */
                        pstring;                    /* STR255           */
                        align word;                 /* keep aligned     */
hfdrStringEnd:
                    case HMPictItem:
hfdrPictBeg:            integer = (hfdrPictEnd[$$ArrayIndex(HFdrArray)] - hfdrPictBeg[$$ArrayIndex(HFdrArray)]) / 8;
                        key int = HMPictItemID;     /* helpType         */
                        integer;                    /* Picture Res ID   */
hfdrPictEnd:
                    case HMStringResItem:
hfdrStringResBeg:       integer = (hfdrStringResEnd[$$ArrayIndex(HFdrArray)] - hfdrStringResBeg[$$ArrayIndex(HFdrArray)]) / 8;
                        key int = HMStringResItemID;/* helpType         */
                        integer; integer;           /* STR# ID, index # */
hfdrStringResEnd:
                    case HMTEResItem:
hfdrTEResBeg:           integer = (hfdrTEResEnd[$$ArrayIndex(HFdrArray)] - hfdrTEResBeg[$$ArrayIndex(HFdrArray)]) / 8;
                        key int = HMTEResItemID;    /* helpType         */
                        integer;                    /* TextEdit res ID  */
hfdrTEResEnd:
                    case HMSTRResItem:
hfdrSTRResBeg:          integer = (hfdrSTRResEnd[$$ArrayIndex(HFdrArray)] - hfdrSTRResBeg[$$ArrayIndex(HFdrArray)]) / 8;
                        key int = HMSTRResItemID;   /* helpType         */
                        integer;                    /* STR res ID       */
hfdrSTRResEnd:
                    case HMSkipItem:
hfdrSkipBeg:            integer = (hfdrSkipEnd[$$ArrayIndex(HFdrArray)] - hfdrSkipBeg[$$ArrayIndex(HFdrArray)]) / 8;
                        key int = HMSkipItemID;     /* skip item (leave a hole) */
hfdrSkipEnd:
                };
        };
};

#endif __BALLOONTYPES.R__



æKY Cmdo.r
æKL
boldCmdo
BoxID
CheckOptionID
cmdo
CMDOVersion
condenseCmdo
DoItButtonID
DummyID
EditPopUpID
extendCmdo
FilesID
italicCmdo
ListID
MultiFilesID
MultiRegularEntryID
NestedDialogID
outlineCmdo
PictOrIconID
PopUpID
RadioButtonsID
RedirectionID
RegularEntryID
shadowCmdo
TextBoxID
TextTitleID
TriStateButtonsID
underlineCmdo
VersionDialogID

æKY FilesID
æFr Cmdo.r
æT #define
æD #define FilesID                      0
æC

æKY MultiFilesID
æFr Cmdo.r
æT #define
æD #define MultiFilesID                 1
æC

æKY CheckOptionID
æFr Cmdo.r
æT #define
æD #define CheckOptionID                2
æC

æKY RadioButtonsID
æFr Cmdo.r
æT #define
æD #define RadioButtonsID               3
æC

æKY RegularEntryID
æFr Cmdo.r
æT #define
æD #define RegularEntryID               4
æC

æKY MultiRegularEntryID
æFr Cmdo.r
æT #define
æD #define MultiRegularEntryID          5
æC

æKY BoxID
æFr Cmdo.r
æT #define
æD #define BoxID                        6
æC

æKY TextBoxID
æFr Cmdo.r
æT #define
æD #define TextBoxID                    7
æC

æKY PopUpID
æFr Cmdo.r
æT #define
æD #define PopUpID                      8
æC

æKY NestedDialogID
æFr Cmdo.r
æT #define
æD #define NestedDialogID               9
æC

æKY TextTitleID
æFr Cmdo.r
æT #define
æD #define TextTitleID                 10
æC

æKY RedirectionID
æFr Cmdo.r
æT #define
æD #define RedirectionID               11
æC

æKY EditPopUpID
æFr Cmdo.r
æT #define
æD #define EditPopUpID                 12
æC

æKY TriStateButtonsID
æFr Cmdo.r
æT #define
æD #define TriStateButtonsID           13
æC

æKY ListID
æFr Cmdo.r
æT #define
æD #define ListID                      14
æC

æKY PictOrIconID
æFr Cmdo.r
æT #define
æD #define PictOrIconID                15
æC

æKY DummyID
æFr Cmdo.r
æT #define
æD #define DummyID                     16
æC

æKY DoItButtonID
æFr Cmdo.r
æT #define
æD #define DoItButtonID                17
æC

æKY VersionDialogID
æFr Cmdo.r
æT #define
æD #define VersionDialogID             18
æC

æKY CMDOVersion
æFr Cmdo.r
æT #define
æD #define CMDOVersion                  8
æC

æKY boldCmdo
æFr Cmdo.r
æT #define
æD #define bold             1
æC

æKY italicCmdo
æFr Cmdo.r
æT #define
æD #define italic           2
æC

æKY underlineCmdo
æFr Cmdo.r
æT #define
æD #define underline        4
æC

æKY outlineCmdo
æFr Cmdo.r
æT #define
æD #define outline          8
æC

æKY shadowCmdo
æFr Cmdo.r
æT #define
æD #define shadow          16
æC

æKY condenseCmdo
æFr Cmdo.r
æT #define
æD #define condense        32
æC

æKY extendCmdo
æFr Cmdo.r
æT #define
æD #define extend          64
æC

æKY cmdo
æFr Cmdo.r
æT
æD type 'cmdo' {
  integer = CMDOVersion;                                    /* Version number */
  integer = $$CountOf(dialogs);                             /* # of dialogs, at least 1 */
  array dialogs {
    integer;                                                /* height of the dialog */
    cstring;                                                /* text displayed in help window */
    align word;

    integer = $$CountOf(itemArray);                         /* # of items */

    /* The order in which Commando writes out the options is the same order in which the
       items in this array are entered in your resource declaration.  This is important
       for those commands which have position dependent parameters. */

    wide array itemArray {
        switch {
            case NotDependent:
                key int = 0;

            case Or:
                key byte = 1;
                byte = $$CountOf(OrArray);
                wide array OrArray {
                    int;                                    /* item number dependent upon */
                };

            case And:
                key byte = 2;
                byte = $$CountOf(AndArray);
                wide array AndArray {
                    int;                                    /* item number dependent upon */
                };
        };
        switch {
            case Files:
                key byte = FilesID;
                byte    InputFile,                          /* These types require the  */
                        InputFileOrDir,                     /* 'Additional' case below. */
                        InputOrOutputFile,
                        InputOrOutputOrDir,

                        OutputFile,                         /* These types require the  */
                        OutputFileOrDir,                    /* 'NoMore' case below.     */
                        DirOnly;
                switch {
                    case OptionalFile:
                        /* Using this case makes a popup with two or three items.
                           This first item is used to select a default file or to
                           select no file.  The second (and third) item(s) are used
                           to select input or output files. */
                        key int = 0;
                        rect;                               /* bounds of title */
                        rect;                               /* bounds of display box */
                        cstring;                            /* title */
                        cstring;                            /* default file */
                        cstring;                            /* option to return before file */
                        cstring;                            /* If this item is dependent upon
                                                               another Files item, an extension
                                                               can be specified here to be added
                                                               to the dependents file. */
                        cstring;                            /* help text for popup */
                        byte        dim, dontDim;           /* Normally, dependent items are
                                                               dimmed if the parent is disabled,
                                                               if this field is "dontDim", then
                                                               this item won't be dimmed */
                        /* These next three strings are the strings displayed in the popup.  Most
                           of the file types have only two strings but InputOrOutputFile and
                           InputOrOutputOrDir require three strings.  If a string is set to "",
                           Commando will use a built-in default. */
                        cstring;                            /* popup item #1 */
                        cstring;                            /* popup item #2 */
                        cstring;                            /* popup item #3 */

                    case RequiredFile:
                        /* Using this case makes a button that goes directly to standard
                           file.  Use this case when a file is required and the user doesn't
                           have the choice of a default file or no file. */
                        key int = 1;
                        rect;                               /* bounds of button */
                        cstring;                            /* title of button */
                        cstring;                            /* option to return before file */
                        cstring;                            /* help text for button */
                };

                /* Some file types take additional information.  See the comment next to the
                   file types to find out which case to choose here. */
                switch {
                    case Additional:
                        key byte = 0;
                        cstring;                                    /* For InputOrOutputFile, an option
                                                                       can be specified when a new
                                                                       (or output) file is chosen. */
                        cstring FilterTypes = ":";                  /* preferred file extension (i.e. ".c")
                                                                       If null, no radio buttons will be
                                                                       displayed.  If FilterTypes is used,
                                                                       the radio buttons will toggle
                                                                       between showing files only with
                                                                       the types below and all files */
                        cstring;                                    /* title of only files button */
                        cstring;                                    /* title of all files button */
                        byte = $$CountOf(TypesArray);               /* up to 4 types may be specified */
                        align word;
                        array TypesArray {
                            literal longint     text = 'TEXT',      /* desired input file type, specify */
                                                obj  = 'OBJ ',      /* no type for all types */
                                                appl = 'APPL',
                                                da   = 'DFIL',
                                                tool = 'MPST';
                        };

                    case NoMore:
                        key byte = 1;
                };

            case MultiFiles:
                key byte = MultiFilesID;
                cstring;                                    /* button title */
                cstring;                                    /* help text for button */
                align word;
                rect;                                       /* bounds of button */
                cstring;                                    /* message like " Source files to compile: " */
                cstring;                                    /* option returned before each
                                                               filename. Can be null */
                switch {
                    case MultiInputFiles:
                        key byte = 0;
                        byte = $$CountOf(MultiTypesArray);          /* up to 4 types may be specified */
                        align word;
                        array MultiTypesArray {
                            literal longint     text = 'TEXT',      /* desired input file type, specify no type */
                                                obj  = 'OBJ ',      /* for all types */
                                                appl = 'APPL',
                                                da   = 'DFIL',
                                                tool = 'MPST';
                        };
                        cstring FilterTypes = ":";                  /* preferred file extension (i.e. ".c")
                                                                       If null, no radio buttons will be
                                                                       displayed.  If FilterTypes is used,
                                                                       the radio buttons will toggle
                                                                       between showing files only with
                                                                       the types below and all files */
                        cstring;                                    /* title of only files button */
                        cstring;                                    /* title of all files button */

                    case MultiDirs:
                        key byte = 1;

                    case MultiInputFilesAndDirs:
                        key byte = 2;

                    case MultiOutputFiles:
                        key byte = 3;
                };

            case CheckOption:
                key byte = CheckOptionID;
                byte    NotSet, Set;                        /* whether button is set or not */
                rect;                                       /* bounds */
                cstring;                                    /* title */
                cstring;                                    /* option returned */
                cstring;                                    /* help text for button */

            case RadioButtons:
                key byte = RadioButtonsID;
                byte = $$CountOf(radioArray);               /* # of buttons */
                wide array radioArray {
                    rect;                                   /* bounds */
                    cstring;                                /* title */
                    cstring;                                /* option returned */
                    byte    NotSet, Set;                    /* whether button is set or not */
                    cstring;                                /* help text for button */
                    align word;
                };

            case RegularEntry:
                key byte = RegularEntryID;
                cstring;                                    /* title */
                align word;
                rect;                                       /* bounds of title */
                rect;                                       /* bounds of input box */
                cstring;                                    /* default value */
                byte        ignoreCase, keepCase;           /* the default value is never displayed
                                                               in the commando window.  If what the
                                                               user types in the textedit window
                                                               matches the default value, then that
                                                               value isn't displayed.  This flag
                                                               tells Commando whether to ignore case
                                                               when comparing the contents of the textedit
                                                               window with the default value. */
                cstring;                                    /* option returned */
                cstring;                                    /* help text for entry */

            case MultiRegularEntry: /* For scrollable, lists of an option */
                key byte = MultiRegularEntryID;
                cstring;                                    /* title */
                align word;
                rect;                                       /* bounds of title */
                rect;                                       /* bounds of input list */
                byte = $$CountOf(DefEntryList);
                array DefEntryList {
                    cstring;                                /* default values */
                };
                cstring;                                    /* option returned. Each value
                                                               will be preceded with this
                                                               option */
                cstring;                                    /* help text for entry */

            case Box:       /* Can be used to draw lines too */
                key byte = BoxID;
                byte            black, gray;                /* color of object */
                rect;                                       /* bounds of box or line */

            case TextBox:   /* Draws a box with title in upper-left */
                key byte = TextBoxID;
                byte            black, gray;                /* color of object */
                rect;                                       /* bounds of box or line */
                cstring;                                    /* title */

            case TextTitle:
                key byte = TextTitleID;
                byte        plain;                          /* style of text */
                rect;                                       /* bounds of title */
                int         systemFont;                     /* font number to use */
                int         systemSize;                     /* font size to use */
                cstring;                                    /* the text to display */

            case PopUp:
                key byte = PopUpID;
                byte        Window, Alias, Font, Set;       /* popup type */
                rect;                                       /* bounds of title */
                rect;                                       /* bounds of popup line */
                cstring;                                    /* title */
                cstring;                                    /* option returned */
                cstring;                                    /* help text for popup */
                byte        noDefault, hasDefault;          /* hasDefault if first item is "Default Value" */

            case EditPopUp:
                key byte = EditPopUpID;
                /* For MenuItem, this EditPopUp must be dependent upon another EditPopUp
                   of the MenuTitle type so that the control knows whose menu items to
                   display.

                   For FontSize, this EditPopUp must be dependent upon a PopUp of the
                   Font type so that the control knows what sizes of the font exist. */

                byte    MenuTitle, MenuItem,                /* Type of editable pop-up */
                        FontSize, Alias, Set;
                rect;                                       /* bounds of title */
                rect;                                       /* bounds of text edit area */
                cstring;                                    /* title */
                cstring;                                    /* option to return */
                cstring;                                    /* help text for textedit part */
                cstring;                                    /* help text for popup part */

            case NestedDialog:
                key byte = NestedDialogID;
                byte;                                       /* the number of the dialog
                                                               to call.  It must be greater
                                                               than the current dialog */
                rect;                                       /* bounds of button */
                cstring;                                    /* button's title */
                cstring;                                    /* help text for button */

            case Redirection:
                key byte = RedirectionID;
                byte    StandardOutput, DiagnosticOutput,   /* the type of redirection */
                        StandardInput;
                point;                                      /* upper-left point of the whole contraption */

            case TriStateButtons:
                key byte = TriStateButtonsID;
                byte = $$CountOf(threeStateArray);          /* # of buttons */
                cstring;                                    /* option returned */
                wide array threeStateArray {
                    align word;
                    rect;                                   /* bounds */
                    cstring;                                /* title */
                    cstring;                                /* string for Clear state */
                    cstring;                                /* string for DontTouch state */
                    cstring;                                /* string for Set state */
                    cstring;                                /* help text for button */
                };

            case List:      /* Puts up a list of "things" and allows multiple selections */
                key byte = ListID;
                byte        Volumes, ShellVars,
                            Windows, Aliases;               /* what to display in the list */
                cstring;                                    /* option to return before each "thing" */
                cstring;                                    /* title */
                align word;
                rect;                                       /* bounds of title */
                rect;                                       /* bounds of list selection box */
                cstring;                                    /* help text for selection box */

            case PictOrIcon:
                key byte = PictOrIconID;
                byte    Icon, Picture;                      /* display a picture or icon */
                int;                                        /* resource id of icon/picture */
                rect;                                       /* display bounds */

            case Dummy:
                key byte = DummyID;

            case DoItButton:                                /* Allows the 'do it' button to be dependent */
                key byte = DoItButtonID;

            case VersionDialog:                             /* Display a dialog when the version # is clicked */
                key byte = VersionDialogID;
                switch {
                    case VersionString:                     /* Version string embedded right here */
                        key byte = 0;
                        cstring;                            /* Version string of tool (e.g. V2.0) */

                    case VersionResource:                   /* Versions string comes from another resource */
                        key byte = 1;
                        literal longint;                    /* resource type of pascal string containing version string */
                        integer;                            /* resource id of version string */
                };
                cstring;                                    /* Version text for help window */
                align word;
                integer     noDialog;                       /* Rsrc id of 'DLOG' */
                    /* NOTE •1: if there is no modal dialog to display when the version
                       string is clicked, set the rsrc id to zero (noDialog).

                       NOTE •2: if the version string comes from another resource (VersionResource),
                       the string must be the first thing in the resource and the string must be
                       a pascal-style string.  A 'STR ' resource is an example of a resource that
                       fits the bill.

                       NOTE •3: if the modal dialog is to have a filter proc, the proc
                       must be linked as a 'fltr' resource with the same resource id
                       as the dialog. */
        };
        align word;
    };
    align word;
  };
};

#endif __CMDO.R__



æKY CTBTypes.r
æKL
cbnd
fbnd
flst
tbnd

æKY cbnd
æFr CTBTypes.r
æT
æD type 'cbnd' {
        integer = $$CountOf(TypeArray) - 1;
        array TypeArray {
                literal longint;                                /* Type                 */
                integer = $$CountOf(IDArray) - 1;
                wide array IDArray {
                        integer;                                /* Local ID             */
                        integer;                                /* Actual ID            */
                };
        };
};
æC

æKY flst
æFr CTBTypes.r
æT
æD
/*----------------------------flst • Font Family List----------------------------*/
type 'flst' {
        integer = $$CountOf(Fonts);                             /* # of fonts           */
        array Fonts {
            pstring;                                            /*      Font NAME           */
            align word;
            unsigned hex integer    plain;                      /*      Font Style      */
            integer;                                            /*      Font Size       */
            integer;                                            /*      Font Mode       */
        };
};
æC

æKY fbnd
æFr CTBTypes.r
æT
æD
type 'fbnd' as 'cbnd';
æC

æKY tbnd
æFr CTBTypes.r
æT
æD
type 'tbnd' as 'cbnd';




æKY InstallerTypes.r
æKL
actionAtomFlags
addAssertionKey
addAuditRecKey
addPackagesKey
addUserDescriptionKey
alwaysFalseKey
alwaysTrueKey
assertionList
bootBlockAtomFlags
BootBlockUpdateFlags
checkAllAssertionsKey
checkAnyAssertionKey
checkAnyAuditRecKey
checkAuditRecKey
checkFileContainsRsrcByIDKey
checkFileContainsRsrcByNameKey
checkFileCountryCodeKey
checkFileDataForkExistsKey
checkFileRsrcForkExistsKey
checkFileVersionKey
checkGestaltKey
checkMinMemoryKey
checkMoreThanOneAssertionKey
checkTgtVolSizeKey
checkUserFunctionKey
delInstall
delRemove
evenIf
evenPaddedString
fileAtomFlags
fileSpecFlags
fileSpecID
gestaltList
icmt
inaa
inat
inbb
indo
infa
infr
infs
inpk
inra
inrl
IntegerList
invs
LongIntList
noByID
noCopy
noDelInstall
noDelRemove
noEvenIf
noKeepExisting
noLeaveAloneIfNewer
notChangeOnInstall
notChangeOnRemove
notNameMustMatch
notShowsOnCustom
noTypeCrMustMatch
noUpdateOnly
opcodeFlags
OSType
packageFlags
packageList
partSpec
region
reportSysErrorKey
reportVolErrorKey
resourceAtomFlags
rsrcID
RsrcName
rsrcType
RuleList
TargetVolReqs
updateOnly
Version

æKY region
æFr InstallerTypes.r
æT #define
æD #include "SysTypes.r"                                   /* For region codes */

/* For those using pre-7.0 "SysTypes.r" we need to define region.  It used */
/* to be country, but became region in 7.0 */

#ifndef region
#define region country
#endif
æC

æKY evenPaddedString
æFr InstallerTypes.r
æT #define
æD #define evenPaddedString
    pstring;
    align word
æC

æKY OSType
æFr InstallerTypes.r
æT #define
æD #define OSType
    literal longint
æC

æKY rsrcType
æFr InstallerTypes.r
æT #define
æD #define rsrcType
    OSType                                              /* type of a rsrc which must exist in system */
        patchrsrcType = 'PTCH',
        userFunctionType = 'infn',
        auditrsrcType = 'audt'
æC

æKY rsrcID
æFr InstallerTypes.r
æT #define
æD #define rsrcID
    integer                                             /* ID of a rsrc which must exist in system */
        macPlusPatch = 117,
        macSEPatch = 630,
        macIIPatch = 376,
        portablePatch = 890,
        macIIciPatch = 1660,
        oldAuroraPatch = 1657
æC

æKY RsrcName
æFr InstallerTypes.r
æT #define
æD #define RsrcName
    evenPaddedString
æC

æKY packageFlags
æFr InstallerTypes.r
æT #define
æD #define packageFlags
        boolean     doesntShowOnCustom, showsOnCustom;      /* should show up on Custom screen   */
        boolean     notRemovable, removable;                /* this package can be removed   */
        boolean     forceRestart, dontForceRestart;         /* should installing this package for a restart? */
        fill bit[13]                                        /* Reserved */
æC

æKY notShowsOnCustom
æFr InstallerTypes.r
æT #define
æD #define notShowsOnCustom     doesntShowOnCustom               /* Old wording */
æC

æKY partSpec
æFr InstallerTypes.r
æT #define
æD #define partSpec
        rsrcType;                                           /* Part Type: inpk, infa, inra… */
        rsrcID                                              /* Part ID */
æC

æKY inpk
æFr InstallerTypes.r
æT
æD
type 'inpk' {
        switch {
            case format0:
                key integer = 0;                            /* Package Format version */
                packageFlags;                               /* Package Flags */
                unsigned integer;                           /* icmt ID */
                unsigned longint;                           /* Package Size */
                evenPaddedString;                           /* Package Name */
                unsigned integer = $$CountOf(partsList);    /* Parts List */
                wide array partsList {
                    partSpec;                               /* Parts Spec */
                };

        };
};
æC

æKY icmt
æFr InstallerTypes.r
æT
æD
type 'icmt' {                                               /* Installer comment */
        unsigned hex longint;                               /* Creation Date  */
        unsigned hex longint;                               /* Version */
        rsrcID;                                             /* Icon ID */
        evenPaddedString;                                   /* Comment Text */
};
æC

æKY fileSpecID
æFr InstallerTypes.r
æT #define
æD #define fileSpecID
        rsrcID
æC

æKY fileSpecFlags
æFr InstallerTypes.r
æT #define
æD #define fileSpecFlags
        boolean     noSearchForFile, SearchForFile;         /* Search (tgt only) if not found in given path*/
        boolean     TypeCrNeedNotMatch, TypeCrMustMatch;    /* Type and creator must match  */
        fill bit[14]                                        /* currently unused */
æC

æKY noTypeCrMustMatch
æFr InstallerTypes.r
æT #define
æD #define noTypeCrMustMatch    TypeCrNeedNotMatch
æC

æKY infs
æFr InstallerTypes.r
æT
æD
type    'infs' {
        literal longint;                                    /* File Type    */
        literal longint;                                    /* File Creator */
        unsigned hex longint;                               /* Creation Date*/
        fileSpecFlags;                                      /* File Spec Flags */
        evenPaddedString;                                   /* Full Path */
};
æC

æKY opcodeFlags
æFr InstallerTypes.r
æT #define
æD #define opcodeFlags
        boolean     dontDeleteWhenRemoving, deleteWhenRemoving;         /* Remove file or rsrc if remove clicked */
        boolean     dontDeleteWhenInstalling, deleteWhenInstalling;     /* Delete target before copy    */
        boolean     dontCopy, copy;                         /* Copy file or rsrc to destination */
        fill bit[3]                                         /* Reserved */
æC

æKY delRemove
æFr InstallerTypes.r
æT #define
æD #define delRemove        deleteWhenRemoving
æC

æKY noDelRemove
æFr InstallerTypes.r
æT #define
æD #define noDelRemove      dontDeleteWhenRemoving
æC

æKY delInstall
æFr InstallerTypes.r
æT #define
æD #define delInstall       deleteWhenInstalling
æC

æKY noDelInstall
æFr InstallerTypes.r
æT #define
æD #define noDelInstall     dontDeleteWhenInstalling
æC

æKY noCopy
æFr InstallerTypes.r
æT #define
æD #define noCopy           dontCopy
æC

æKY fileAtomFlags
æFr InstallerTypes.r
æT #define
æD #define fileAtomFlags
        opcodeFlags;
        fill bit[5];
        boolean     updateEvenIfNewer, leaveAloneIfNewer;   /* OK for a newer version of this file to exist */
        boolean     updateExisting, keepExisting;           /* Keep tgt file if it already exists */
        boolean     copyIfNewOrUpdate, copyIfUpdate;        /* Only update if target exists */
        boolean     noRsrcFork, rsrcFork;                   /* Apply operation to rsrc fork */
        boolean     noDataFork, dataFork                    /* Apply operation to data fork */
æC

æKY noLeaveAloneIfNewer
æFr InstallerTypes.r
æT #define
æD #define noLeaveAloneIfNewer  updateEvenIfNewer
æC

æKY noKeepExisting
æFr InstallerTypes.r
æT #define
æD #define noKeepExisting       updateExisting
æC

æKY noUpdateOnly
æFr InstallerTypes.r
æT #define
æD #define noUpdateOnly         copyIfNewOrUpdate
æC

æKY updateOnly
æFr InstallerTypes.r
æT #define
æD #define updateOnly           copyIfUpdate
æC

æKY infa
æFr InstallerTypes.r
æT
æD
type 'infa' {
        switch {
            case format0:
                key integer = 0;                            /* File Atom Format version */
                fileAtomFlags;                              /* File Atom Flags        */
                rsrcID;                                     /* tgt file spec ID */
                rsrcID;                                     /* src file spec ID */
                unsigned longInt;                           /* File Size     */
                evenPaddedString;                           /* Atom Description     */
        };
};
æC

æKY resourceAtomFlags
æFr InstallerTypes.r
æT #define
æD #define resourceAtomFlags
        opcodeFlags;
        fill bit[3];                                        /* Reserved */
        boolean     noTgtRequired, tgtRequired;             /* target req or can be created by another inra */
        boolean     updateExisting, keepExisting;           /* Keep tgt rsrc if it already exists */
        boolean     copyIfNewOrUpdate, copyIfUpdate;        /* Only update if target exists */
        boolean     dontIgnoreProtection, ignoreProtection; /* Do it even if rsrc protected */
        boolean     srcNeedExist, srcNeedNotExist;          /* Rsrc need not exist on source */
        boolean     byName, byID;                           /* Use name or id to find rsrc  */
        boolean     nameNeedNotMatch, nameMustMatch         /* name must match*/
æC

æKY evenIf
æFr InstallerTypes.r
æT #define
æD #define evenIf               ignoreProtection
æC

æKY noEvenIf
æFr InstallerTypes.r
æT #define
æD #define noEvenIf             dontIgnoreProtection
æC

æKY noByID
æFr InstallerTypes.r
æT #define
æD #define noByID               byName
æC

æKY notNameMustMatch
æFr InstallerTypes.r
æT #define
æD #define notNameMustMatch     nameNeedNotMatch
æC

æKY inra
æFr InstallerTypes.r
æT
æD
type 'inra' {
        switch {
            case format0:
                key integer = 0;                            /* Resource Atom Format version */
                resourceAtomFlags;                          /* Resource Atom Flags */
                rsrcID;                                     /* tgt file spec ID */
                rsrcID;                                     /* src file spec ID */
                rsrcType;                                   /* Resource Type */
                integer;                                    /* Source ID */
                integer;                                    /* Target ID */
                unsigned longInt;                           /* Resource Size */
                evenPaddedString;                           /* Atom Description */
                evenPaddedString;                           /* Resource Name */
        };
};
æC

æKY bootBlockAtomFlags
æFr InstallerTypes.r
æT #define
æD #define bootBlockAtomFlags
        fill bit[14];
        boolean     dontChangeOnInstall, changeOnInstall;   /* change parameter if we're installing */
        boolean     dontChangeOnRemove, changeOnRemove      /* change parameter if we're removing */
æC

æKY notChangeOnInstall
æFr InstallerTypes.r
æT #define
æD #define notChangeOnInstall   dontChangeOnInstall
æC

æKY notChangeOnRemove
æFr InstallerTypes.r
æT #define
æD #define notChangeOnRemove    dontChangeOnRemove
æC

æKY BootBlockUpdateFlags
æFr InstallerTypes.r
æT #define
æD #define BootBlockUpdateFlags
        fill bit[7];
        boolean     replaceBBSysName,
                    saveBBSysName;
        boolean     replaceBBShellName,
                    saveBBShellName;
        boolean     replaceBBDbg1Name,
                    saveBBDbg1Name;
        boolean     replaceBBDbg2Name,
                    saveBBDbg2Name;
        boolean     replaceBBScreenName,
                    saveBBScreenName;
        boolean     replaceBBHelloName,
                    saveBBHelloName;
        boolean     replaceBBScrapName,
                    saveBBScrapName;
        boolean     replaceBBCntFCBs,
                    maxBBCntFCBs;
        boolean     replaceBBCntEvts,
                    maxBBCntEvts


æC

æKY inbb
æFr InstallerTypes.r
æT
æD

type 'inbb' {
        switch {
            case format0:
                key integer = 0;                            /* Boot Block Format version */
                bootBlockAtomFlags;                         /* Boot Block Atom Flags      */

                        /* now case off the type for the boot block value */
                switch {
                    case bbUpdate:
                        key integer = -1;
                        rsrcID;                             /* The file spec ID for the source of the 'boot' resource */
                        bootBlockUpdateFlags;

                    case bbID:
                        key integer = 1;
                        decimal integer;

                    case bbEntry:
                        key integer = 2;
                        decimal longint;

                    case bbVersion:
                        key integer = 3;
                        decimal integer;

                    case bbPageFlags:
                        key integer = 4;
                        decimal integer;

                    case bbSysName:
                        key integer = 5;
                        evenPaddedString;

                    case bbShellName:
                        key integer = 6;
                        evenPaddedString;

                    case bbDbg1Name:
                        key integer = 7;
                        evenPaddedString;

                    case bbDbg2Name:
                        key integer = 8;
                        evenPaddedString;

                    case bbScreenName:
                        key integer = 9;
                        evenPaddedString;

                    case bbHelloName:
                        key integer = 10;
                        evenPaddedString;

                    case bbScrapName:
                        key integer = 11;
                        evenPaddedString;

                    case bbCntFCBs:
                        key integer = 12;
                        decimal integer;

                    case bbCntEvts:
                        key integer = 13;
                        decimal integer;

                    case bb128KSHeap:
                        key integer = 14;
                        decimal longint;

                    case bb256KSHeap:
                        key integer = 15;
                        decimal longint;

                    case bb512KSHeap:
                        key integer = 16;
                        decimal longint;

                    case bbSysHeapSize:                     /* Note - same as 512 */
                        key integer = 16;
                        decimal longint;

                    case bbSysHeapExtra:
                        key integer = 18;
                        decimal longint;

                    case bbSysHeapFract:
                        key integer = 19;
                        decimal longint;
                };
                evenPaddedString;                               /* Boot Block Atom Description */
        };
};

æC

æKY actionAtomFlags
æFr InstallerTypes.r
æT #define
æD #define actionAtomFlags
        fill bit[13];
        boolean     actAfter,                   /* Call this proc after all installations */
                    actBefore;                  /* Call this proc before all installations */
        boolean     dontActOnRemove,
                    actOnRemove;                /* Call this proc when doing a remove */
        boolean     dontActOnInstall,
                    actOnInstall                /* Call this proc when doing an Install */
æC

æKY inaa
æFr InstallerTypes.r
æT
æD
type 'inaa' {
        switch {
            case format0:
                key integer = 0;                            /* Action Atom Format version */
                actionAtomFlags;                            /* Action Atom Flags          */
                partSpec;                                   /* Resource type & id for executable resource */
                longint;                                    /* RefCon that's passed to the executable resource */
                evenPaddedString;                           /* Atom Description     */
        };
};

æC

æKY inat
æFr InstallerTypes.r
æT
æD /*
§ --------------------------------- Audit Trail Atoms ---------------------------------*/
type 'inat' {
        switch {
            case format0:
                key integer = 0;                            /* Version */
                fileSpecID;                                 /* Target File Spec */
                OSType;                                     /* Selector */
                literal longint;                            /* Value */
            };
};

æC

æKY Version
æFr InstallerTypes.r
æT #define
æD #define Version
    hex byte;                                               /* System file Major revision in BCD*/
    hex byte;                                               /* System file Minor revision in BCD*/
    hex byte    development = 0x20,                         /* System file Release stage        */
                alpha = 0x40, beta = 0x60,
                final = 0x80, release = 0x80;
    hex byte                                                /* Non Final */
æC

æKY TargetVolReqs
æFr InstallerTypes.r
æT #define
æD #define TargetVolReqs                                       /* Required Target Volume Description */
    decimal longint                                         /* Minimal Target Disk Size */
        floppy = 0,
        hdFloppy = 1400,
        hardDisk = 10000;
    decimal longint                                         /* Maximal Target Disk Size */
        floppy = 900,
        hdFloppy = 1500,
        hardDisk = 0
æC

æKY IntegerList
æFr InstallerTypes.r
æT #define
æD #define IntegerList
    unsigned integer = $$CountOf(IntegerArray);
    array IntegerArray {
        integer;
    }

æC

æKY LongIntList
æFr InstallerTypes.r
æT #define
æD #define LongIntList
    unsigned integer = $$CountOf(LongIntArray);
    array LongIntArray {
        longint;
    }
æC

æKY packageList
æFr InstallerTypes.r
æT #define
æD #define packageList
    IntegerList

æC

æKY assertionList
æFr InstallerTypes.r
æT #define
æD #define assertionList
    IntegerList

æC

æKY gestaltList
æFr InstallerTypes.r
æT #define
æD #define gestaltList
    LongIntList

æC

æKY alwaysFalseKey
æFr InstallerTypes.r
æT #define
æD #define alwaysFalseKey                          -2
æC

æKY alwaysTrueKey
æFr InstallerTypes.r
æT #define
æD #define alwaysTrueKey                           -1
æC

æKY checkGestaltKey
æFr InstallerTypes.r
æT #define
æD #define checkGestaltKey                          1
æC

æKY checkMinMemoryKey
æFr InstallerTypes.r
æT #define
æD #define checkMinMemoryKey                        2
æC

æKY checkFileDataForkExistsKey
æFr InstallerTypes.r
æT #define
æD #define checkFileDataForkExistsKey               3
æC

æKY checkFileRsrcForkExistsKey
æFr InstallerTypes.r
æT #define
æD #define checkFileRsrcForkExistsKey               4
æC

æKY checkFileContainsRsrcByIDKey
æFr InstallerTypes.r
æT #define
æD #define checkFileContainsRsrcByIDKey             5
æC

æKY checkFileContainsRsrcByNameKey
æFr InstallerTypes.r
æT #define
æD #define checkFileContainsRsrcByNameKey           6
æC

æKY checkFileVersionKey
æFr InstallerTypes.r
æT #define
æD #define checkFileVersionKey                      7
æC

æKY checkFileCountryCodeKey
æFr InstallerTypes.r
æT #define
æD #define checkFileCountryCodeKey                  8
æC

æKY checkTgtVolSizeKey
æFr InstallerTypes.r
æT #define
æD #define checkTgtVolSizeKey                       9
æC

æKY checkUserFunctionKey
æFr InstallerTypes.r
æT #define
æD #define checkUserFunctionKey                    10
æC

æKY checkAllAssertionsKey
æFr InstallerTypes.r
æT #define
æD #define checkAllAssertionsKey                   11
æC

æKY checkAnyAssertionKey
æFr InstallerTypes.r
æT #define
æD #define checkAnyAssertionKey                    12
æC

æKY checkMoreThanOneAssertionKey
æFr InstallerTypes.r
æT #define
æD #define checkMoreThanOneAssertionKey            13
æC

æKY addUserDescriptionKey
æFr InstallerTypes.r
æT #define
æD #define addUserDescriptionKey                   14
æC

æKY addPackagesKey
æFr InstallerTypes.r
æT #define
æD #define addPackagesKey                          15
æC

æKY addAssertionKey
æFr InstallerTypes.r
æT #define
æD #define addAssertionKey                         16
æC

æKY reportVolErrorKey
æFr InstallerTypes.r
æT #define
æD #define reportVolErrorKey                       17
æC

æKY reportSysErrorKey
æFr InstallerTypes.r
æT #define
æD #define reportSysErrorKey                       18
æC

æKY addAuditRecKey
æFr InstallerTypes.r
æT #define
æD #define addAuditRecKey                          19
æC

æKY checkAuditRecKey
æFr InstallerTypes.r
æT #define
æD #define checkAuditRecKey                        20
æC

æKY checkAnyAuditRecKey
æFr InstallerTypes.r
æT #define
æD #define checkAnyAuditRecKey                     21
æC

æKY inrl
æFr InstallerTypes.r
æT
æD
/* The Easy Install Rules */
type 'inrl' {
    switch {
        case format0:
            key integer = 0;
            hex integer = 0;                                            /* Rule Flags for future use */
            unsigned integer = $$CountOf(Rules);
            wide array Rules {
                switch {
                    case alwaysFalse:
                        key integer = alwaysFalseKey;

                    case alwaysTrue:
                        key integer = alwaysTrueKey;

                    case checkGestalt:
                        key integer = checkGestaltKey;
                        OSType;                                         /* Gestalt selector */
                        gestaltList;                                    /* Legal results */

                    case checkMinMemory:
                        key integer = checkMinMemoryKey;
                        decimal longint;

                    case checkFileDataForkExists:
                        key integer = checkFileDataForkExistsKey;
                        fileSpecID;

                    case checkFileRsrcForkExists:
                        key integer = checkFileRsrcForkExistsKey;
                        fileSpecID;

                    case checkFileContainsRsrcByID:
                        key integer = checkFileContainsRsrcByIDKey;
                        fileSpecID;
                        rsrcType;
                        rsrcID;

                    case checkFileContainsRsrcByName:
                        key integer = checkFileContainsRsrcByNameKey;
                        fileSpecID;
                        rsrcType;
                        rsrcName;

                    case checkFileVersion:
                        key integer = checkFileVersionKey;
                        fileSpecID;
                        version;

                    case checkFileCountryCode:
                        key integer = checkFileCountryCodeKey;
                        fileSpecID;
                        integer Region;

                    case checkTgtVolSize:
                        key integer = checkTgtVolSizeKey;
                        targetVolReqs;

                    case checkUserFunction:
                        key integer = checkUserFunctionKey;
                        rsrcType;
                        rsrcID;
                        longint;                    /* RefCon that's passed to the executable resource */

                    case checkAllAssertions:
                        key integer = checkAllAssertionsKey;
                        assertionList;

                    case checkAnyAssertion:
                        key integer = checkAnyAssertionKey;
                        assertionList;

                    case checkMoreThanOneAssertion:
                        key integer = checkMoreThanOneAssertionKey;
                        assertionList;

                    case addUserDescription:
                        key integer = addUserDescriptionKey;
                        evenPaddedString;

                    case addPackages:
                        key integer = addPackagesKey;
                        packageList;

                    case addAssertion:
                        key integer = addAssertionKey;
                        assertionList;

                    case reportVolError:
                        key integer = reportVolErrorKey;
                        evenPaddedString;

                    case reportSysError:
                        key integer = reportSysErrorKey;
                        evenPaddedString;

                    case addAuditRec:
                        key integer = addAuditRecKey;
                        fileSpecID;
                        OSType;
                        literal longint;

                    case checkAuditRec:
                        key integer = checkAuditRecKey;
                        fileSpecID;
                        OSType;
                        literal longint;

                    case checkAnyAuditRec:
                        key integer = checkAnyAuditRecKey;
                        fileSpecID;
                        OSType;
                        longIntList;

            };
        };
    };
};

æC

æKY RuleList
æFr InstallerTypes.r
æT #define
æD #define RuleList  IntegerList
æC

æKY infr
æFr InstallerTypes.r
æT
æD
/* The rule framework */
type 'infr' {
    switch {
        case format0:
            key integer = 0;                                /* Rule framework version */
            unsigned integer = $$CountOf(RuleArray);
            wide array RuleArray {
                boolean pickFirst, pickAll;                 /* which packages to select? */
                fill bit[15];
                ruleList;                                   /* List of rules */
            };
    };
};

æC

æKY indo
æFr InstallerTypes.r
æT
æD
/* The list of disks we may need, and the order we want them to appear in */
/* This is optional. */
type 'indo' {
    switch {
        case format0:
            key integer = 0;                                /* indo version */
            integer = $$Countof(StringArray);
            array StringArray {
                    evenPaddedString;
            };
    };
};
æC

æKY invs
æFr InstallerTypes.r
æT
æD
/* This script resource defines the minimum Installer version that is required */
/* to run the script.  If an Installer app is launched that is older than this */
/* required version, the user receives a dialog telling him/her to run a newer Installer */
/* This is optional. */
type 'invs' {
    switch {
        case format0:
            key integer = 0;
            hex byte;                                               /* Major revision in BCD*/
            hex byte;                                               /* Minor vevision in BCD*/
            hex byte    development = 0x20,                         /* Release stage        */
                        alpha = 0x40,
                        beta = 0x60,
                        final = 0x80, /* or */ release = 0x80;
            hex byte;                                               /* Non-final release #  */
            pstring;                                                /* Short version number */
    };
};



æKY MPWTypes.r
æKL
activMask
autoKeyMask
diskMask
driverMask
DRVW
everyEvent
keyDownMask
keyUpMask
mDownMask
mUpMask
networkMask
updateMask

æKY mDownMask
æFr MPWTypes.r
æT #define
æD #define mDownMask          2         /* Event mask values for drvrEMask */
æC

æKY mUpMask
æFr MPWTypes.r
æT #define
æD #define mUpMask            4
æC

æKY keyDownMask
æFr MPWTypes.r
æT #define
æD #define keyDownMask        8
æC

æKY keyUpMask
æFr MPWTypes.r
æT #define
æD #define keyUpMask         16
æC

æKY autoKeyMask
æFr MPWTypes.r
æT #define
æD #define autoKeyMask       32
æC

æKY updateMask
æFr MPWTypes.r
æT #define
æD #define updateMask        64
æC

æKY diskMask
æFr MPWTypes.r
æT #define
æD #define diskMask         128
æC

æKY activMask
æFr MPWTypes.r
æT #define
æD #define activMask        256
æC

æKY networkMask
æFr MPWTypes.r
æT #define
æD #define networkMask     1024
æC

æKY driverMask
æFr MPWTypes.r
æT #define
æD #define driverMask      2048
æC

æKY everyEvent
æFr MPWTypes.r
æT #define
æD #define everyEvent        -1
æC

æKY DRVW
æFr MPWTypes.r
æT
æD
/*
 * When building a DRVR resource, insert the line:
 *
 *      type 'DRVR' as 'DRVW';
 *
 * in your resource file before your "resource 'DRVR' ..." declaration.
 */

type 'DRVW' {
    boolean = 0;                            /* unused */
    boolean dontNeedLock,    needLock;      /* lock drvr in memory  */
    boolean dontNeedTime,    needTime;      /* for periodic action  */
    boolean dontNeedGoodbye, needGoodbye;   /* call before heap reinit*/
    boolean noStatusEnable,  statusEnable;  /* responds to status   */
    boolean noCtlEnable,     ctlEnable;     /* responds to control  */
    boolean noWriteEnable,   writeEnable;   /* responds to write    */
    boolean noReadEnable,    readEnable;    /* responds to read     */

    byte = 0;                   /* low byte of drvrFlags word unused */

    unsigned integer;           /* driver delay (ticks) */
    integer;                    /* desk acc event mask  */
    integer;                    /* driver menu ID       */

    unsigned integer = 50;      /* offset to DRVRRuntime open   */
    unsigned integer = 54;      /* offset to DRVRRuntime prime  */
    unsigned integer = 58;      /* offset to DRVRRuntime control*/
    unsigned integer = 62;      /* offset to DRVRRuntime status */
    unsigned integer = 66;      /* offset to DRVRRuntime close  */

    pstring[31];                /* driver name */

    hex string;                 /* driver code (use $$resource(...)) */
};

#endif __MPWTYPES.R__



æKY Pict.r
æKL
AppleReserved0092Start
BitsRectpMapRowBytes
BitsRectRowBytes
BkPixPatpMapRowBytes
clipRgnEnd
ClipStart
FillPixPatpMapRowBytes
frameRgnStart
PackBitsRectBits
PICT

æKY PICT
æFr Pict.r
æT
æD type 'PICT' {
    startOfPict:
        unsigned integer = (endOfPict - startOfPict) >> 3;
        Rect;                                   /* Bounds of picture */
        switch {
            case VersionOne:
                key integer = $1101;
                array OpCodes {
                    switch {
                        case NOP:
                            key byte = $00;

                        case clipRgn:
                            key byte = $01;
    clipRgnStart:           integer = (clipRgnEnd[$$ArrayIndex(OpCodes)] - clipRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(clipRgnStart[$$ArrayIndex(OpCodes)]) - 10];
æC

æKY clipRgnEnd
æFr Pict.r
æT
æD     clipRgnEnd:
                        case bkPat:
                            key byte = $02;
                            hex string [8];

                        case txFont:
                            key byte = $03;
                            integer;            /* font */

                        case txFace:
                            key byte = $04;
                            unsigned hex byte;  /* text face */

                        case txMode:
                            key byte = $05;
                            integer     srcCopy, srcOr, srcXor, srcBic, /* mode */
                                        notSrcCopy, notSrcOr, notSrcXor,
                                        notSrcBic, patCopy, patOr, patXor,
                                        patBic, notPatCopy, notPatOr, notPatBic;

                        case spExtra:
                            key byte = $06;
                            unsigned hex longint;

                        case pnSize:
                            key byte = $07;
                            Point;

                        case pnMode:
                            key byte = $08;
                            unsigned hex integer;

                        case pnPat:
                            key byte = $09;
                            hex string [8];

                        case thePat:
                            key byte = $0A;
                            hex string [8];

                        case ovSize:
                            key byte = $0B;
                            Point;

                        case origin:
                            key byte = $0C;
                            integer;            /* dh */
                            integer;            /* dv */

                        case txSize:
                            key byte = $0D;
                            integer;

                        case fgColor:
                            key byte = $0E;
                            longint;

                        case bkColor:
                            key byte = $0F;
                            longint;

                        case txRatio:
                            key byte = $10;
                            Point;              /* numer */
                            Point;              /* denom */

                        case picVersion:
                            key byte = $11;
                            byte;

                        case line:
                            key byte = $20;
                            Point;              /* pnLoc */
                            Point;              /* newPt */

                        case lineFrom:
                            key byte = $21;
                            Point;              /* newPt */

                        case shortLine:
                            key byte = $22;
                            Point;              /* pnLoc */
                            byte;               /* dh */
                            byte;               /* dv */

                        case shortLineFrom:
                            key byte = $23;
                            byte;               /* dh */
                            byte;               /* dv */

                        case longText:
                            key byte = $28;
                            Point;              /* txLoc */
                            pstring;

                        case dhText:
                            key byte = $29;
                            byte;               /* dh */
                            pstring;

                        case dvText:
                            key byte = $2A;
                            byte;               /* dvh */
                            pstring;

                        case dhdvText:
                            key byte = $2B;
                            byte;               /* dh */
                            byte;               /* dv */
                            pstring;

                        case frameRect:
                            key byte = $30;
                            Rect;

                        case paintRect:
                            key byte = $31;
                            Rect;

                        case eraseRect:
                            key byte = $32;
                            Rect;

                        case invertRect:
                            key byte = $33;
                            Rect;

                        case fillRect:
                            key byte = $34;
                            Rect;

                        case frameSameRect:
                            key byte = $38;

                        case paintSameRect:
                            key byte = $39;

                        case eraseSameRect:
                            key byte = $3A;

                        case invertSameRect:
                            key byte = $3B;

                        case fillSameRect:
                            key byte = $3C;

                        case frameRRect:
                            key byte = $40;
                            Rect;

                        case paintRRect:
                            key byte = $41;
                            Rect;

                        case eraseRRect:
                            key byte = $42;
                            Rect;

                        case invertRRect:
                            key byte = $43;
                            Rect;

                        case fillRRect:
                            key byte = $44;
                            Rect;

                        case frameSameRRect:
                            key byte = $48;

                        case paintSameRRect:
                            key byte = $49;

                        case eraseSameRRect:
                            key byte = $4A;

                        case invertSameRRect:
                            key byte = $4B;

                        case fillSameRRect:
                            key byte = $4C;

                        case frameOval:
                            key byte = $50;
                            Rect;

                        case paintOval:
                            key byte = $51;
                            Rect;

                        case eraseOval:
                            key byte = $52;
                            Rect;

                        case invertOval:
                            key byte = $53;
                            Rect;

                        case fillOval:
                            key byte = $54;
                            Rect;

                        case frameSameOval:
                            key byte = $58;

                        case paintSameOval:
                            key byte = $59;

                        case eraseSameOval:
                            key byte = $5A;

                        case invertSameOval:
                            key byte = $5B;

                        case fillSameOval:
                            key byte = $5C;

                        case frameArc:
                            key byte = $60;
                            Rect;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case paintArc:
                            key byte = $61;
                            Rect;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case eraseArc:
                            key byte = $62;
                            Rect;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case invertArc:
                            key byte = $63;
                            Rect;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case fillArc:
                            key byte = $64;
                            Rect;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case frameSameArc:
                            key byte = $68;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case paintSameArc:
                            key byte = $69;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case eraseSameArc:
                            key byte = $6A;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case invertSameArc:
                            key byte = $6B;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case fillSameArc:
                            key byte = $6C;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case framePoly:
                            key byte = $70;
                            integer = $$CountOf(framePoly) * 4 + 10;
                            Rect;                   /* enclosing rectangle */
                            array framePoly {
                                Point;
                            };

                        case paintPoly:
                            key byte = $71;
                            integer = $$CountOf(framePoly) * 4 + 10;
                            Rect;                   /* enclosing rectangle */
                            array framePoly {
                                Point;
                            };

                        case erasePoly:
                            key byte = $72;
                            integer = $$CountOf(framePoly) * 4 + 10;
                            Rect;                   /* enclosing rectangle */
                            array framePoly {
                                Point;
                            };

                        case invertPoly:
                            key byte = $73;
                            integer = $$CountOf(framePoly) * 4 + 10;
                            Rect;                   /* enclosing rectangle */
                            array framePoly {
                                Point;
                            };

                        case fillPoly:
                            key byte = $74;
                            integer = $$CountOf(framePoly) * 4 + 10;
                            Rect;                   /* enclosing rectangle */
                            array framePoly {
                                Point;
                            };

                        case frameSamePoly:
                            key byte = $78;

                        case paintSamePoly:
                            key byte = $79;

                        case eraseSamePoly:
                            key byte = $7A;

                        case invertSamePoly:
                            key byte = $7B;

                        case fillSamePoly:
                            key byte = $7C;

                        case frameRgn:
                            key byte = $80;
æC

æKY frameRgnStart
æFr Pict.r
æT
æD     frameRgnStart:          integer = (frameRgnEnd[$$ArrayIndex(OpCodes)] - frameRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(frameRgnStart[$$ArrayIndex(OpCodes)]) - 10];
    frameRgnEnd:
                        case paintRgn:
                            key byte = $81;
    paintRgnStart:          integer = (paintRgnEnd[$$ArrayIndex(OpCodes)] - paintRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(paintRgnStart[$$ArrayIndex(OpCodes)]) - 10];
    paintRgnEnd:
                        case eraseRgn:
                            key byte = $82;
    eraseRgnStart:          integer = (eraseRgnEnd[$$ArrayIndex(OpCodes)] - eraseRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(eraseRgnStart[$$ArrayIndex(OpCodes)]) - 10];
    eraseRgnEnd:
                        case invertRgn:
                            key byte = $83;
    invertRgnStart:         integer = (invertRgnEnd[$$ArrayIndex(OpCodes)] - invertRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(invertRgnStart[$$ArrayIndex(OpCodes)]) - 10];
    invertRgnEnd:
                        case fillRgn:
                            key byte = $84;
    fillRgnStart:           integer = (fillRgnEnd[$$ArrayIndex(OpCodes)] - fillRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(fillRgnStart[$$ArrayIndex(OpCodes)]) - 10];
    fillRgnEnd:
                        case frameSameRgn:
                            key byte = $88;

                        case paintSameRgn:
                            key byte = $89;

                        case eraseSameRgn:
                            key byte = $8A;

                        case invertSameRgn:
                            key byte = $8B;

                        case fillSameRgn:
                            key byte = $8C;

                        case bitsRect:
                            key byte = $90;
æC

æKY BitsRectRowBytes
æFr Pict.r
æT
æD     BitsRectRowBytes:       integer;                    /* row bytes */
    BitsRectBounds:         Rect;                       /* bounds */
                            Rect;                       /* srcRect */
                            Rect;                       /* destRect */
                            integer     srcCopy, srcOr, srcXor, srcBic, /* mode */
                                        notSrcCopy, notSrcOr, notSrcXor,
                                        notSrcBic, patCopy, patOr, patXor,
                                        patBic, notPatCopy, notPatOr, notPatBic;
                            hex string [($$BitField(BitsRectBounds[$$ArrayIndex(OpCodes)],32,16)
                                        - $$BitField(BitsRectBounds[$$ArrayIndex(OpCodes)],0,16))
                                        * $$Word(BitsRectRowBytes[$$ArrayIndex(OpCodes)])];

                        case bitsRgn:
                            key byte = $91;
    BitsRgnRowBytes:        integer;                    /* row bytes */
    BitsRgnBounds:          Rect;                       /* bounds */
                            Rect;                       /* srcRect */
                            Rect;                       /* destRect */
                            integer     srcCopy, srcOr, srcXor, srcBic, /* mode */
                                        notSrcCopy, notSrcOr, notSrcXor,
                                        notSrcBic, patCopy, patOr, patXor,
                                        patBic, notPatCopy, notPatOr, notPatBic;
    bitsRgnStart:           integer = (bitsRgnEnd[$$ArrayIndex(OpCodes)] - bitsRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(bitsRgnStart[$$ArrayIndex(OpCodes)]) - 10];
    bitsRgnEnd:
                            hex string [($$BitField(BitsRgnBounds[$$ArrayIndex(OpCodes)],32,16)
                                        - $$BitField(BitsRgnBounds[$$ArrayIndex(OpCodes)],0,16))
                                        * $$Word(BitsRgnRowBytes[$$ArrayIndex(OpCodes)])];

                        case packBitsRect:
                            key byte = $98;
    PackBitsRectRowBytes:   integer;                    /* row bytes */
    PackBitsRectBounds:     Rect;                       /* bounds */
                            Rect;                       /* srcRect */
                            Rect;                       /* destRect */
                            integer     srcCopy, srcOr, srcXor, srcBic, /* mode */
                                        notSrcCopy, notSrcOr, notSrcXor,
                                        notSrcBic, patCopy, patOr, patXor,
                                        patBic, notPatCopy, notPatOr, notPatBic;
    PackBitsBits:           hex string [$$PackedSize(PackBitsBits[$$ArrayIndex(OpCodes)],
                                        $$Word(PackBitsRectRowBytes[$$ArrayIndex(OpCodes)]),
                                        ($$BitField(PackBitsRectBounds[$$ArrayIndex(OpCodes)],32,16)
                                        - $$BitField(PackBitsRectBounds[$$ArrayIndex(OpCodes)],0,16)))];

                        case packBitsRgn:
                            key byte = $99;
    packBitsRgnRowBytes:    integer;                    /* row bytes */
    packBitsRgnBounds:      Rect;                       /* bounds */
                            Rect;                       /* srcRect */
                            Rect;                       /* destRect */
                            integer     srcCopy, srcOr, srcXor, srcBic, /* mode */
                                        notSrcCopy, notSrcOr, notSrcXor,
                                        notSrcBic, patCopy, patOr, patXor,
                                        patBic, notPatCopy, notPatOr, notPatBic;
    packBitsRgnStart:       integer = (packBitsRgnEnd[$$ArrayIndex(OpCodes)] - packBitsRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(packBitsRgnStart[$$ArrayIndex(OpCodes)]) - 10];
    packBitsRgnEnd:         hex string [$$PackedSize(packBitsRgnEnd[$$ArrayIndex(OpCodes)],
                                        $$Word(packBitsRgnRowBytes[$$ArrayIndex(OpCodes)]),
                                        ($$BitField(packBitsRgnBounds[$$ArrayIndex(OpCodes)],32,16)
                                        - $$BitField(packBitsRgnBounds[$$ArrayIndex(OpCodes)],0,16)))];

                        case shortComment:
                            key byte = $A0;
                            integer;            /* kind */

                        case longComment:
                            key byte = $A1;
                            integer;            /* kind */
    longCommentStart:       integer = (longCommentEnd[$$ArrayIndex(OpCodes)] - longCommentStart[$$ArrayIndex(OpCodes)] - 16) >> 3;
                            hex string [$$Word(longCommentStart[$$ArrayIndex(OpCodes)])];
    longCommentEnd:
                    };
                };
                byte = $FF;     /* End of picture */

            case VersionTwo:
                key longint = $001102ff;        /* Version op + version */
                array OpCodes {
                    switch {
                        case Clip:
                            key integer = $0001;
æC

æKY ClipStart
æFr Pict.r
æT
æD     ClipStart:              integer = (ClipEnd[$$ArrayIndex(OpCodes)] - ClipStart[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(ClipStart[$$ArrayIndex(OpCodes)]) - 10];
    ClipEnd:
                        case BkPat:
                            key integer = $0002;
                            hex string [8];

                        case TxFont:
                            key integer = $0003;
                            integer;            /* font */

                        case TxFace:
                            key integer = $0004;
                            unsigned hex byte;  /* text face */

                        case TxMode:
                            key integer = $0005;
                            integer     srcCopy, srcOr, srcXor, srcBic, /* mode */
                                        notSrcCopy, notSrcOr, notSrcXor,
                                        notSrcBic, patCopy, patOr, patXor,
                                        patBic, notPatCopy, notPatOr, notPatBic;

                        case SpExtra:
                            key integer = $0006;
                            unsigned hex longint;

                        case PnSize:
                            key integer = $0007;
                            Point;

                        case PnMode:
                            key integer = $0008;
                            unsigned hex integer;

                        case PnPat:
                            key integer = $0009;
                            hex string [8];

                        case FillPat:
                            key integer = $000A;
                            hex string [8];

                        case OvSize:
                            key integer = $000B;
                            Point;

                        case Origin:
                            key integer = $000C;
                            integer;            /* dh */
                            integer;            /* dv */

                        case TxSize:
                            key integer = $000D;
                            integer;

                        case FgColor:
                            key integer = $000E;
                            longint;

                        case BkColor:
                            key integer = $000F;
                            longint;

                        case TxRatio:
                            key integer = $0010;
                            Point;              /* numer */
                            Point;              /* denom */

                        case Version:
                            key integer = $0011;
                            byte;

                        case BkPixPat:
                            key integer = $0012;
                            switch {
                                case newPattern:
                                    key integer = 1;
                                    hex string [8];         /* old-style pattern    */
                                    unsigned bitstring[1] = 1;                              /* New pixMap flag      */
                                    unsigned bitstring[2] = 0;                              /* Must be 0            */
æC

æKY BkPixPatpMapRowBytes
æFr Pict.r
æT
æD     BkPixPatpMapRowBytes:           unsigned bitstring[13];                                 /* Offset to next row   */
    BkPixPatBounds:                 rect;                                                   /* Bitmap bounds        */
                                    integer;                                                /* pixMap vers number   */
                                    integer unpacked;                                       /* Packing format       */
                                    unsigned longint;                                       /* Size of pixel data   */
                                    unsigned hex longint;                                   /* h. resolution (ppi) (fixed) */
                                    unsigned hex longint;                                   /* v. resolution (ppi) (fixed) */
                                    integer         chunky, chunkyPlanar, planar;           /* Pixel storage format */
                                    integer;                                                /* # bits in pixel      */
                                    integer;                                                /* # components in pixel*/
                                    integer;                                                /* # bits per field     */
                                    unsigned longint;                                       /* Offset to next plane */
                                    unsigned longint;                                       /* Offset to color table*/
                                    fill long;                                              /* Reserved             */
                                    /* Color Table */
                                    unsigned hex longint;                                   /* ctSeed               */
                                    integer;                                                /* ctFlags              */
                                    integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
                                    wide array ColorSpec {
                                            integer;                                        /* value                */
                                            unsigned integer;                               /* RGB: red             */
                                            unsigned integer;                               /*      green           */
                                            unsigned integer;                               /*      blue            */
                                    };
                                    /* If rowBytes < 8 then data is unpacked,
                                       if >= 8, then data is packed */
    BkPixPatBits:                   hex string [($$BitField(BkPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) < 8) *
                                                $$BitField(BkPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) +
                                                ($$BitField(BkPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) >= 8) *
                                                $$PackedSize(BkPixPatBits[$$ArrayIndex(OpCodes)],
                                                $$BitField(BkPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
                                                ($$BitField(BkPixPatBounds[$$ArrayIndex(OpCodes)],32,16)
                                                - $$BitField(BkPixPatBounds[$$ArrayIndex(OpCodes)],0,16)))];

                                case ditherPattern:
                                    key integer = 2;
                                    hex string [8];         /* old-style pattern    */
                                    unsigned integer;       /* RGB: red             */
                                    unsigned integer;       /*      green           */
                                    unsigned integer;       /*      blue            */
                            };

                        case PnPixPat:
                            key integer = $0013;
                            switch {
                                case newPattern:
                                    key integer = 1;
                                    hex string [8];         /* old-style pattern    */
                                    unsigned bitstring[1] = 1;                              /* New pixMap flag      */
                                    unsigned bitstring[2] = 0;                              /* Must be 0            */
    PnPixPatpMapRowBytes:           unsigned bitstring[13];                                 /* Offset to next row   */
    PnPixPatBounds:                 rect;                                                   /* Bitmap bounds        */
                                    integer;                                                /* pixMap vers number   */
                                    integer unpacked;                                       /* Packing format       */
                                    unsigned longint;                                       /* Size of pixel data   */
                                    unsigned hex longint;                                   /* h. resolution (ppi) (fixed) */
                                    unsigned hex longint;                                   /* v. resolution (ppi) (fixed) */
                                    integer         chunky, chunkyPlanar, planar;           /* Pixel storage format */
                                    integer;                                                /* # bits in pixel      */
                                    integer;                                                /* # components in pixel*/
                                    integer;                                                /* # bits per field     */
                                    unsigned longint;                                       /* Offset to next plane */
                                    unsigned longint;                                       /* Offset to color table*/
                                    fill long;                                              /* Reserved             */
                                    /* Color Table */
                                    unsigned hex longint;                                   /* ctSeed               */
                                    integer;                                                /* ctFlags              */
                                    integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
                                    wide array ColorSpec {
                                            integer;                                        /* value                */
                                            unsigned integer;                               /* RGB: red             */
                                            unsigned integer;                               /*      green           */
                                            unsigned integer;                               /*      blue            */
                                    };
                                    /* If rowBytes < 8 then data is unpacked,
                                       if >= 8, then data is packed */
    PnPixPatBits:                   hex string [($$BitField(PnPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) < 8) *
                                                $$BitField(PnPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) +
                                                ($$BitField(PnPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) >= 8) *
                                                $$PackedSize(PnPixPatBits[$$ArrayIndex(OpCodes)],
                                                $$BitField(PnPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
                                                ($$BitField(PnPixPatBounds[$$ArrayIndex(OpCodes)],32,16)
                                                - $$BitField(PnPixPatBounds[$$ArrayIndex(OpCodes)],0,16)))];

                                case ditherPattern:
                                    key integer = 2;
                                    hex string [8];         /* old-style pattern    */
                                    unsigned integer;       /* RGB: red             */
                                    unsigned integer;       /*      green           */
                                    unsigned integer;       /*      blue            */
                            };

                        case FillPixPat:
                            key integer = $0014;
                            switch {
                                case newPattern:
                                    key integer = 1;
                                    hex string [8];         /* old-style pattern    */
                                    unsigned bitstring[1] = 1;                              /* New pixMap flag      */
                                    unsigned bitstring[2] = 0;                              /* Must be 0            */
æC

æKY FillPixPatpMapRowBytes
æFr Pict.r
æT
æD     FillPixPatpMapRowBytes:         unsigned bitstring[13];                                 /* Offset to next row   */
    FillPixPatBounds:                   rect;                                                   /* Bitmap bounds        */
                                    integer;                                                /* pixMap vers number   */
                                    integer unpacked;                                       /* Packing format       */
                                    unsigned longint;                                       /* Size of pixel data   */
                                    unsigned hex longint;                                   /* h. resolution (ppi) (fixed) */
                                    unsigned hex longint;                                   /* v. resolution (ppi) (fixed) */
                                    integer         chunky, chunkyPlanar, planar;           /* Pixel storage format */
                                    integer;                                                /* # bits in pixel      */
                                    integer;                                                /* # components in pixel*/
                                    integer;                                                /* # bits per field     */
                                    unsigned longint;                                       /* Offset to next plane */
                                    unsigned longint;                                       /* Offset to color table*/
                                    fill long;                                              /* Reserved             */
                                    /* Color Table */
                                    unsigned hex longint;                                   /* ctSeed               */
                                    integer;                                                /* ctFlags              */
                                    integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
                                    wide array ColorSpec {
                                            integer;                                        /* value                */
                                            unsigned integer;                               /* RGB: red             */
                                            unsigned integer;                               /*      green           */
                                            unsigned integer;                               /*      blue            */
                                    };
                                    /* If rowBytes < 8 then data is unpacked,
                                       if >= 8, then data is packed */
    FillPixPatBits:                 hex string [($$BitField(FillPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) < 8) *
                                                $$BitField(FillPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) +
                                                ($$BitField(FillPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) >= 8) *
                                                $$PackedSize(FillPixPatBits[$$ArrayIndex(OpCodes)],
                                                $$BitField(FillPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
                                                ($$BitField(FillPixPatBounds[$$ArrayIndex(OpCodes)],32,16)
                                                - $$BitField(FillPixPatBounds[$$ArrayIndex(OpCodes)],0,16)))];

                                case ditherPattern:
                                    key integer = 2;
                                    hex string [8];         /* old-style pattern    */
                                    unsigned integer;       /* RGB: red             */
                                    unsigned integer;       /*      green           */
                                    unsigned integer;       /*      blue            */
                            };

                        case PnLocHFrac:
                            key integer = $0015;
                            unsigned hex integer;

                        case ChExtra:
                            key integer = $0016;
                            integer;                        /* extra for each character */

                        case AppleReserved0017:
                            key integer = $0017;

                        case AppleReserved0018:
                            key integer = $0018;

                        case AppleReserved0019:
                            key integer = $0019;

                        case RGBFgCol:
                            key integer = $001A;
                            unsigned integer;       /* RGB: red             */
                            unsigned integer;       /*      green           */
                            unsigned integer;       /*      blue            */

                        case RGBBkCol:
                            key integer = $001B;
                            unsigned integer;       /* RGB: red             */
                            unsigned integer;       /*      green           */
                            unsigned integer;       /*      blue            */

                        case HiliteMode:
                            key integer = $001C;

                        case HiliteColor:
                            key integer = $001D;
                            unsigned integer;       /* RGB: red             */
                            unsigned integer;       /*      green           */
                            unsigned integer;       /*      blue            */

                        case DefHilite:
                            key integer = $001E;

                        case OpColor:
                            key integer = $001F;
                            unsigned integer;       /* RGB: red             */
                            unsigned integer;       /*      green           */
                            unsigned integer;       /*      blue            */

                        case Line:
                            key integer = $0020;
                            Point;                  /* pnLoc */
                            Point;                  /* newPt */

                        case LineFrom:
                            key integer = $0021;
                            Point;                  /* newPt */

                        case ShortLine:
                            key integer = $0022;
                            Point;                  /* pnLoc */
                            byte;                   /* dh */
                            byte;                   /* dv */

                        case ShortLineFrom:
                            key integer = $0023;
                            byte;                   /* dh */
                            byte;                   /* dv */

                        case AppleReserved0024:
                            key integer = $0024;
                AR24:       unsigned integer = (AR24End - AR24) / 8 - 2;
                            hex string [$$Word(AR24)];
                AR24End:

                        case AppleReserved0025:
                            key integer = $0025;
                AR25:       unsigned integer = (AR25End - AR25) / 8 - 2;
                            hex string [$$Word(AR25)];
                AR25End:

                        case AppleReserved0026:
                            key integer = $0026;
                AR26:       unsigned integer = (AR26End - AR26) / 8 - 2;
                            hex string [$$Word(AR26)];
                AR26End:

                        case AppleReserved0027:
                            key integer = $0027;
                AR27:       unsigned integer = (AR27End - AR27) / 8 - 2;
                            hex string [$$Word(AR27)];
                AR27End:

                        case LongText:
                            key integer = $0028;
                            Point;              /* txLoc */
                            pstring;            /* text */

                        case DHText:
                            key integer = $0029;
                            byte;               /* dh */
                            pstring;            /* text */

                        case DVText:
                            key integer = $002A;
                            byte;               /* dv */
                            pstring;            /* text */

                        case DHDVText:
                            key integer = $002A;
                            byte;               /* dh */
                            byte;               /* dv */
                            pstring;            /* text */

                        case AppleReserved002C:
                            key integer = $002C;
                AR2C:       unsigned integer = (AR2CEnd - AR2C) / 8 - 2;
                            hex string [$$Word(AR2C)];
                AR2CEnd:

                        case AppleReserved002D:
                            key integer = $002D;
                AR2D:       unsigned integer = (AR2DEnd - AR2D) / 8 - 2;
                            hex string [$$Word(AR2D)];
                AR2DEnd:

                        case AppleReserved002E:
                            key integer = $002E;
                AR2E:       unsigned integer = (AR2EEnd - AR2E) / 8 - 2;
                            hex string [$$Word(AR2E)];
                AR2EEnd:

                        case AppleReserved002F:
                            key integer = $002F;
                AR2F:       unsigned integer = (AR2FEnd - AR2F) / 8 - 2;
                            hex string [$$Word(AR2F)];
                AR2FEnd:

                        case FrameRect:
                            key integer = $0030;
                            Rect;

                        case PaintRect:
                            key integer = $0031;
                            Rect;

                        case EraseRect:
                            key integer = $0032;
                            Rect;

                        case InvertRect:
                            key integer = $0033;
                            Rect;

                        case FillRect:
                            key integer = $0034;
                            Rect;

                        case AppleReserved0035:
                            key integer = $0035;
                            Rect;

                        case AppleReserved0036:
                            key integer = $0036;
                            Rect;

                        case AppleReserved0037:
                            key integer = $0037;
                            Rect;

                        case FrameSameRect:
                            key integer = $0038;

                        case PaintSameRect:
                            key integer = $0039;

                        case EraseSameRect:
                            key integer = $003A;

                        case InvertSameRect:
                            key integer = $003B;

                        case FillSameRect:
                            key integer = $003C;

                        case AppleReserved003D:
                            key integer = $003D;

                        case AppleReserved003E:
                            key integer = $003E;

                        case AppleReserved003F:
                            key integer = $003F;

                        case FrameRRect:
                            key integer = $0040;
                            Rect;

                        case PaintRRect:
                            key integer = $0041;
                            Rect;

                        case EraseRRect:
                            key integer = $0042;
                            Rect;

                        case InvertRRect:
                            key integer = $0043;
                            Rect;

                        case FillRRect:
                            key integer = $0044;
                            Rect;

                        case AppleReserved0045:
                            key integer = $0045;
                            Rect;

                        case AppleReserved0046:
                            key integer = $0046;
                            Rect;

                        case AppleReserved0047:
                            key integer = $0047;
                            Rect;

                        case FrameSameRRect:
                            key integer = $0048;

                        case PaintSameRRect:
                            key integer = $0049;

                        case EraseSameRRect:
                            key integer = $004A;

                        case InvertSameRRect:
                            key integer = $004B;

                        case FillSameRRect:
                            key integer = $004C;

                        case AppleReserved004D:
                            key integer = $004D;

                        case AppleReserved004E:
                            key integer = $004E;

                        case AppleReserved004F:
                            key integer = $004F;

                        case FrameOval:
                            key integer = $0050;
                            Rect;

                        case PaintOval:
                            key integer = $0051;
                            Rect;

                        case EraseOval:
                            key integer = $0052;
                            Rect;

                        case InvertOval:
                            key integer = $0053;
                            Rect;

                        case FillOval:
                            key integer = $0054;
                            Rect;

                        case AppleReserved0055:
                            key integer = $0055;
                            Rect;

                        case AppleReserved0056:
                            key integer = $0056;
                            Rect;

                        case AppleReserved0057:
                            key integer = $0057;
                            Rect;

                        case FrameSameOval:
                            key integer = $0058;

                        case PaintSameOval:
                            key integer = $0059;

                        case EraseSameOval:
                            key integer = $005A;

                        case InvertSameOval:
                            key integer = $005B;

                        case FillSameOval:
                            key integer = $005C;

                        case AppleReserved005D:
                            key integer = $005D;

                        case AppleReserved005E:
                            key integer = $005E;

                        case frameArc:
                            key integer = $0060;
                            Rect;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case paintArc:
                            key integer = $0061;
                            Rect;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case eraseArc:
                            key integer = $0062;
                            Rect;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case invertArc:
                            key integer = $0063;
                            Rect;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case fillArc:
                            key integer = $0064;
                            Rect;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case AppleReserved0065:
                            key integer = $0065;
                            Rect;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case AppleReserved0066:
                            key integer = $0066;
                            Rect;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case AppleReserved0067:
                            key integer = $0067;
                            Rect;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case frameSameArc:
                            key integer = $0068;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case paintSameArc:
                            key integer = $0069;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case eraseSameArc:
                            key integer = $006A;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case invertSameArc:
                            key integer = $006B;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case fillSameArc:
                            key integer = $006C;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case AppleReserved006D:
                            key integer = $006D;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case AppleReserved006E:
                            key integer = $006E;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case AppleReserved006F:
                            key integer = $006F;
                            integer;                /* startAngle */
                            integer;                /* arcAngle */

                        case framePoly:
                            key integer = $0070;
                            integer = $$CountOf(framePoly) * 4 + 10;
                            Rect;                   /* enclosing rectangle */
                            array framePoly {
                                Point;
                            };

                        case paintPoly:
                            key integer = $0071;
                            integer = $$CountOf(framePoly) * 4 + 10;
                            Rect;                   /* enclosing rectangle */
                            array framePoly {
                                Point;
                            };

                        case erasePoly:
                            key integer = $0072;
                            integer = $$CountOf(framePoly) * 4 + 10;
                            Rect;                   /* enclosing rectangle */
                            array framePoly {
                                Point;
                            };

                        case invertPoly:
                            key integer = $0073;
                            integer = $$CountOf(framePoly) * 4 + 10;
                            Rect;                   /* enclosing rectangle */
                            array framePoly {
                                Point;
                            };

                        case fillPoly:
                            key integer = $0074;
                            integer = $$CountOf(framePoly) * 4 + 10;
                            Rect;                   /* enclosing rectangle */
                            array framePoly {
                                Point;
                            };

                        case AppleReserved0075:
                            key integer = $0075;
                            integer = $$CountOf(framePoly) * 4 + 10;
                            Rect;                   /* enclosing rectangle */
                            array framePoly {
                                Point;
                            };

                        case AppleReserved0076:
                            key integer = $0076;
                            integer = $$CountOf(framePoly) * 4 + 10;
                            Rect;                   /* enclosing rectangle */
                            array framePoly {
                                Point;
                            };

                        case AppleReserved0077:
                            key integer = $0077;
                            integer = $$CountOf(framePoly) * 4 + 10;
                            Rect;                   /* enclosing rectangle */
                            array framePoly {
                                Point;
                            };

                        case frameSamePoly:
                            key integer = $0078;

                        case paintSamePoly:
                            key integer = $0079;

                        case eraseSamePoly:
                            key integer = $007A;

                        case invertSamePoly:
                            key integer = $007B;

                        case fillSamePoly:
                            key integer = $007C;

                        case AppleReserved007D:
                            key integer = $007D;

                        case AppleReserved007E:
                            key integer = $007E;

                        case AppleReserved007F:
                            key integer = $007F;

                        case frameRgn:
                            key integer = $0080;
æC

æKY BitsRectpMapRowBytes
æFr Pict.r
æT
æD     frameRgnStart2:         integer = (frameRgnEnd2[$$ArrayIndex(OpCodes)] - frameRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(frameRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
    frameRgnEnd2:
                        case paintRgn:
                            key integer = $0081;
    paintRgnStart2:         integer = (paintRgnEnd2[$$ArrayIndex(OpCodes)] - paintRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(paintRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
    paintRgnEnd2:
                        case eraseRgn:
                            key integer = $0082;
    eraseRgnStart2:         integer = (eraseRgnEnd2[$$ArrayIndex(OpCodes)] - eraseRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(eraseRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
    eraseRgnEnd2:
                        case invertRgn:
                            key integer = $0083;
    invertRgnStart2:        integer = (invertRgnEnd2[$$ArrayIndex(OpCodes)] - invertRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(invertRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
    invertRgnEnd2:
                        case fillRgn:
                            key integer = $0084;
    fillRgnStart2:          integer = (fillRgnEnd2[$$ArrayIndex(OpCodes)] - fillRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(fillRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
    fillRgnEnd2:
                        case AppleReserved0085:
                            key integer = $0085;
    AppleReserved0085Start:integer = (AppleReserved0085End[$$ArrayIndex(OpCodes)] - AppleReserved0085Start[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(AppleReserved0085Start[$$ArrayIndex(OpCodes)]) - 10];
    AppleReserved0085End:
                        case AppleReserved0086:
                            key integer = $0086;
    AppleReserved0086Start: integer = (AppleReserved0086End[$$ArrayIndex(OpCodes)] - AppleReserved0086Start[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(AppleReserved0086Start[$$ArrayIndex(OpCodes)]) - 10];
    AppleReserved0086End:
                        case AppleReserved0087:
                            key integer = $0087;
    AppleReserved0087Start: integer = (AppleReserved0087End[$$ArrayIndex(OpCodes)] - AppleReserved0087Start[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(AppleReserved0087Start[$$ArrayIndex(OpCodes)]) - 10];
    AppleReserved0087End:
                        case frameSameRgn:
                            key integer = $0088;

                        case paintSameRgn:
                            key integer = $0089;

                        case eraseSameRgn:
                            key integer = $008A;

                        case invertSameRgn:
                            key integer = $008B;

                        case fillSameRgn:
                            key integer = $008C;

                        case AppleReserved008D:
                            key integer = $008D;

                        case AppleReserved008E:
                            key integer = $008E;

                        case AppleReserved008F:
                            key integer = $008F;

                        case BitsRect:
                            key integer = $0090;
                            unsigned bitstring[1] = 1;                              /* New pixMap flag      */
                            unsigned bitstring[2] = 0;                              /* Must be 0            */
    BitsRectpMapRowBytes:   unsigned bitstring[13];                                 /* Offset to next row   */
    BitsRectBounds2:        rect;                                                   /* Bitmap bounds        */
                            integer;                                                /* pixMap vers number   */
                            integer unpacked;                                       /* Packing format       */
                            unsigned longint;                                       /* Size of pixel data   */
                            unsigned hex longint;                                   /* h. resolution (ppi) (fixed) */
                            unsigned hex longint;                                   /* v. resolution (ppi) (fixed) */
                            integer         chunky, chunkyPlanar, planar;           /* Pixel storage format */
                            integer;                                                /* # bits in pixel      */
                            integer;                                                /* # components in pixel*/
                            integer;                                                /* # bits per field     */
                            unsigned longint;                                       /* Offset to next plane */
                            unsigned longint;                                       /* Offset to color table*/
                            fill long;                                              /* Reserved             */
                            /* Color Table */
                            unsigned hex longint;                                   /* ctSeed               */
                            integer;                                                /* ctFlags              */
                            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
                            wide array ColorSpec {
                                    integer;                                        /* value                */
                                    unsigned integer;                               /* RGB: red             */
                                    unsigned integer;                               /*      green           */
                                    unsigned integer;                               /*      blue            */
                            };
                            Rect;                       /* srcRect */
                            Rect;                       /* destRect */
                            integer     srcCopy, srcOr, srcXor, srcBic, /* mode */
                                        notSrcCopy, notSrcOr, notSrcXor,
                                        notSrcBic, patCopy, patOr, patXor,
                                        patBic, notPatCopy, notPatOr, notPatBic,
                                        blend = 32, addPin, addOver, subPin,
                                        adMax = 37, subOver, adMin;
    BitsRectBits:           hex string [$$BitField(BitsRectpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) *
                                        ($$BitField(BitsRectBounds2[$$ArrayIndex(OpCodes)],32,16)
                                        - $$BitField(BitsRectBounds2[$$ArrayIndex(OpCodes)],0,16))];


                        case BitsRgn:
                            key integer = $0091;
                            unsigned bitstring[1] = 1;                              /* New pixMap flag      */
                            unsigned bitstring[2] = 0;                              /* Must be 0            */
    BitsRgnpMapRowBytes:    unsigned bitstring[13];                                 /* Offset to next row   */
    BitsRgnBounds2:         rect;                                                   /* Bitmap bounds        */
                            integer;                                                /* pixMap vers number   */
                            integer unpacked;                                       /* Packing format       */
                            unsigned longint;                                       /* Size of pixel data   */
                            unsigned hex longint;                                   /* h. resolution (ppi) (fixed) */
                            unsigned hex longint;                                   /* v. resolution (ppi) (fixed) */
                            integer         chunky, chunkyPlanar, planar;           /* Pixel storage format */
                            integer;                                                /* # bits in pixel      */
                            integer;                                                /* # components in pixel*/
                            integer;                                                /* # bits per field     */
                            unsigned longint;                                       /* Offset to next plane */
                            unsigned longint;                                       /* Offset to color table*/
                            fill long;                                              /* Reserved             */
                            /* Color Table */
                            unsigned hex longint;                                   /* ctSeed               */
                            integer;                                                /* ctFlags              */
                            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
                            wide array ColorSpec {
                                    integer;                                        /* value                */
                                    unsigned integer;                               /* RGB: red             */
                                    unsigned integer;                               /*      green           */
                                    unsigned integer;                               /*      blue            */
                            };
                            Rect;                       /* srcRect */
                            Rect;                       /* destRect */
                            integer     srcCopy, srcOr, srcXor, srcBic, /* mode */
                                        notSrcCopy, notSrcOr, notSrcXor,
                                        notSrcBic, patCopy, patOr, patXor,
                                        patBic, notPatCopy, notPatOr, notPatBic,
                                        blend = 32, addPin, addOver, subPin,
                                        adMax = 37, subOver, adMin;
    BitsRgnStart2:          integer = (BitsRgnEnd2[$$ArrayIndex(OpCodes)] - BitsRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(BitsRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
    BitsRgnEnd2:            hex string [$$PackedSize(BitsRgnEnd2[$$ArrayIndex(OpCodes)],
                                        $$BitField(BitsRgnpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
                                        ($$BitField(BitsRgnBounds2[$$ArrayIndex(OpCodes)],32,16)
                                        - $$BitField(BitsRgnBounds2[$$ArrayIndex(OpCodes)],0,16)))];

                        case AppleReserved0092:
                            key integer = $0092;
æC

æKY AppleReserved0092Start
æFr Pict.r
æT
æD     AppleReserved0092Start: unsigned integer = (AppleReserved0092End[$$ArrayIndex(OpCodes)] - AppleReserved0092Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
                            hex string [$$Word(AppleReserved0092Start[$$ArrayIndex(OpCodes)])];
    AppleReserved0092End:
                        case AppleReserved0093:
                            key integer = $0093;
    AppleReserved0093Start: unsigned integer = (AppleReserved0093End[$$ArrayIndex(OpCodes)] - AppleReserved0093Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
                            hex string [$$Word(AppleReserved0093Start[$$ArrayIndex(OpCodes)])];
    AppleReserved0093End:
                        case AppleReserved0094:
                            key integer = $0094;
    AppleReserved0094Start: unsigned integer = (AppleReserved0094End[$$ArrayIndex(OpCodes)] - AppleReserved0094Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
                            hex string [$$Word(AppleReserved0094Start[$$ArrayIndex(OpCodes)])];
    AppleReserved0094End:
                        case AppleReserved0095:
                            key integer = $0095;
    AppleReserved0095Start: unsigned integer = (AppleReserved0095End[$$ArrayIndex(OpCodes)] - AppleReserved0095Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
                            hex string [$$Word(AppleReserved0095Start[$$ArrayIndex(OpCodes)])];
    AppleReserved0095End:
                        case AppleReserved0096:
                            key integer = $0096;
    AppleReserved0096Start: unsigned integer = (AppleReserved0096End[$$ArrayIndex(OpCodes)] - AppleReserved0096Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
                            hex string [$$Word(AppleReserved0096Start[$$ArrayIndex(OpCodes)])];
    AppleReserved0096End:
                        case AppleReserved0097:
                            key integer = $0097;
    AppleReserved0097Start: unsigned integer = (AppleReserved0097End[$$ArrayIndex(OpCodes)] - AppleReserved0097Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
                            hex string [$$Word(AppleReserved0097Start[$$ArrayIndex(OpCodes)])];
    AppleReserved0097End:
                        case PackBitsRect:
                            key integer = $0098;
                            unsigned bitstring[1] = 1;                              /* New pixMap flag      */
                            unsigned bitstring[2] = 0;                              /* Must be 0            */
    PackBitsRectpMapRowBytes:unsigned bitstring[13];                                    /* Offset to next row   */
    PackBitsRectBounds2:    rect;                                                   /* Bitmap bounds        */
                            integer;                                                /* pixMap vers number   */
                            integer unpacked;                                       /* Packing format       */
                            unsigned longint;                                       /* Size of pixel data   */
                            unsigned hex longint;                                   /* h. resolution (ppi) (fixed) */
                            unsigned hex longint;                                   /* v. resolution (ppi) (fixed) */
                            integer         chunky, chunkyPlanar, planar;           /* Pixel storage format */
                            integer;                                                /* # bits in pixel      */
                            integer;                                                /* # components in pixel*/
                            integer;                                                /* # bits per field     */
                            unsigned longint;                                       /* Offset to next plane */
                            unsigned longint;                                       /* Offset to color table*/
                            fill long;                                              /* Reserved             */
                            /* Color Table */
                            unsigned hex longint;                                   /* ctSeed               */
                            integer;                                                /* ctFlags              */
                            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
                            wide array ColorSpec {
                                    integer;                                        /* value                */
                                    unsigned integer;                               /* RGB: red             */
                                    unsigned integer;                               /*      green           */
                                    unsigned integer;                               /*      blue            */
                            };
                            Rect;                       /* srcRect */
                            Rect;                       /* destRect */
                            integer     srcCopy, srcOr, srcXor, srcBic, /* mode */
                                        notSrcCopy, notSrcOr, notSrcXor,
                                        notSrcBic, patCopy, patOr, patXor,
                                        patBic, notPatCopy, notPatOr, notPatBic,
                                        blend = 32, addPin, addOver, subPin,
                                        adMax = 37, subOver, adMin;
æC

æKY PackBitsRectBits
æFr Pict.r
æT
æD     PackBitsRectBits:       hex string [$$PackedSize(PackBitsRectBits[$$ArrayIndex(OpCodes)],
                                        $$BitField(PackBitsRectpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
                                        ($$BitField(PackBitsRectBounds2[$$ArrayIndex(OpCodes)],32,16)
                                        - $$BitField(PackBitsRectBounds2[$$ArrayIndex(OpCodes)],0,16)))];

                        case PackBitsRgn:
                            key integer = $0099;
                            unsigned bitstring[1] = 1;                              /* New pixMap flag      */
                            unsigned bitstring[2] = 0;                              /* Must be 0            */
    PackBitsRgnpMapRowBytes:unsigned bitstring[13];                                 /* Offset to next row   */
    PackBitsRgnBounds2: rect;                                                       /* Bitmap bounds        */
                            integer;                                                /* pixMap vers number   */
                            integer unpacked;                                       /* Packing format       */
                            unsigned longint;                                       /* Size of pixel data   */
                            unsigned hex longint;                                   /* h. resolution (ppi) (fixed) */
                            unsigned hex longint;                                   /* v. resolution (ppi) (fixed) */
                            integer         chunky, chunkyPlanar, planar;           /* Pixel storage format */
                            integer;                                                /* # bits in pixel      */
                            integer;                                                /* # components in pixel*/
                            integer;                                                /* # bits per field     */
                            unsigned longint;                                       /* Offset to next plane */
                            unsigned longint;                                       /* Offset to color table*/
                            fill long;                                              /* Reserved             */
                            /* Color Table */
                            unsigned hex longint;                                   /* ctSeed               */
                            integer;                                                /* ctFlags              */
                            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
                            wide array ColorSpec {
                                    integer;                                        /* value                */
                                    unsigned integer;                               /* RGB: red             */
                                    unsigned integer;                               /*      green           */
                                    unsigned integer;                               /*      blue            */
                            };
                            Rect;                       /* srcRect */
                            Rect;                       /* destRect */
                            integer     srcCopy, srcOr, srcXor, srcBic, /* mode */
                                        notSrcCopy, notSrcOr, notSrcXor,
                                        notSrcBic, patCopy, patOr, patXor,
                                        patBic, notPatCopy, notPatOr, notPatBic,
                                        blend = 32, addPin, addOver, subPin,
                                        adMax = 37, subOver, adMin;
    packBitsRgnStart2:      integer = (packBitsRgnEnd2[$$ArrayIndex(OpCodes)] - packBitsRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
                            Rect;               /* region's enclosing rect */
                            hex string [$$Word(packBitsRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
    packBitsRgnEnd2:        hex string [$$PackedSize(packBitsRgnEnd2[$$ArrayIndex(OpCodes)],
                                        $$BitField(PackBitsRgnpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
                                        ($$BitField(PackBitsRgnBounds2[$$ArrayIndex(OpCodes)],32,16)
                                        - $$BitField(PackBitsRgnBounds2[$$ArrayIndex(OpCodes)],0,16)))];

                        case AppleReserved009A:
                            key integer = $009A;
    AppleReserved009AStart: unsigned integer = (AppleReserved009AEnd[$$ArrayIndex(OpCodes)] - AppleReserved009AStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
                            hex string [$$Word(AppleReserved009AStart[$$ArrayIndex(OpCodes)])];
    AppleReserved009AEnd:
                        case AppleReserved009B:
                            key integer = $009B;
    AppleReserved009BStart: unsigned integer = (AppleReserved009BEnd[$$ArrayIndex(OpCodes)] - AppleReserved009BStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
                            hex string [$$Word(AppleReserved009BStart[$$ArrayIndex(OpCodes)])];
    AppleReserved009BEnd:
                        case AppleReserved009C:
                            key integer = $009C;
    AppleReserved009CStart: unsigned integer = (AppleReserved009CEnd[$$ArrayIndex(OpCodes)] - AppleReserved009CStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
                            hex string [$$Word(AppleReserved009CStart[$$ArrayIndex(OpCodes)])];
    AppleReserved009CEnd:
                        case AppleReserved009D:
                            key integer = $009D;
    AppleReserved009DStart: unsigned integer = (AppleReserved009DEnd[$$ArrayIndex(OpCodes)] - AppleReserved009DStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
                            hex string [$$Word(AppleReserved009DStart[$$ArrayIndex(OpCodes)])];
    AppleReserved009DEnd:
                        case AppleReserved009E:
                            key integer = $009E;
    AppleReserved009EStart: unsigned integer = (AppleReserved009EEnd[$$ArrayIndex(OpCodes)] - AppleReserved009EStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
                            hex string [$$Word(AppleReserved009EStart[$$ArrayIndex(OpCodes)])];
    AppleReserved009EEnd:
                        case AppleReserved009F:
                            key integer = $009F;
    AppleReserved009FStart: unsigned integer = (AppleReserved009FEnd[$$ArrayIndex(OpCodes)] - AppleReserved009FStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
                            hex string [$$Word(AppleReserved009FStart[$$ArrayIndex(OpCodes)])];
    AppleReserved009FEnd:
                        case ShortComment:
                            key integer = $00A0;
                            integer;                            /* comment kind */

                        case LongComment:
                            key integer = $00A1;
                            integer;                            /* comment kind */
    longCommentStart2:      integer = (longCommentEnd2[$$ArrayIndex(OpCodes)] - longCommentStart2[$$ArrayIndex(OpCodes)] - 16) >> 3;
                            hex string [$$Word(longCommentStart2[$$ArrayIndex(OpCodes)])];
    longCommentEnd2:
                        case OpEndPic:
                            key integer = $00FF;

                        case HeaderOp:
                            key integer = $0C00;
                            longint     Version2 = -1;
                            /* Fixed point bounding box */
                            unsigned hex longint;
                            unsigned hex longint;
                            unsigned hex longint;
                            unsigned hex longint;
                            longint     Version2 = -1;      /* Reserved */

                    };
                    align word;
                };
        };
    endOfPict:
};

#endif __PICT.R__



æKY SIOW.h
æKL
__kErrStrings
__kMinSize
__kPrefSize
__mApple
__mEdit
__mFile
__mFont
__mSize
__rAboutAlert
__rDocWindow
__rHScroll
__rMenuBar
__rSaveAlert
__rUserAlert
__rVScroll

æKY __kPrefSize
æFr SIOW.h
æT #define
æD #ifndef __kPrefSize
#define __kPrefSize 122 /*Default max app size*/
æC

æKY __kMinSize
æFr SIOW.h
æT #define
æD #endif
#ifndef __kMinSize
#define __kMinSize 38 /*Default min app size*/
æC

æKY __mApple
æFr SIOW.h
æT #define
æD #endif

/* The following constants are used to identify menus and their items. */
/* NOTE: resources IDs 20000-20010 are reserved fur use by SIOW */

#define __mApple 20000 /*File menu*/
æC

æKY __mFile
æFr SIOW.h
æT #define
æD #define __mFile 20001 /*File menu*/
æC

æKY __mEdit
æFr SIOW.h
æT #define
æD #define __mEdit 20002 /*Edit menu*/
æC

æKY __mFont
æFr SIOW.h
æT #define
æD #define __mFont 20003 /*Font menu*/
æC

æKY __mSize
æFr SIOW.h
æT #define
æD #define __mSize 20004 /*Font menu*/
æC

æKY __rMenuBar
æFr SIOW.h
æT #define
æD #define __rMenuBar 20000 /*application's menu bar*/
æC

æKY __rAboutAlert
æFr SIOW.h
æT #define
æD #define __rAboutAlert 20000 /*about alert*/
æC

æKY __rUserAlert
æFr SIOW.h
æT #define
æD #define __rUserAlert 20001 /*user error alert*/
æC

æKY __rSaveAlert
æFr SIOW.h
æT #define
æD #define __rSaveAlert 20002 /*save changes alert*/
æC

æKY __rDocWindow
æFr SIOW.h
æT #define
æD #define __rDocWindow 20000 /*applications's window*/
æC

æKY __rVScroll
æFr SIOW.h
æT #define
æD #define __rVScroll 20000 /*vertical scrollbar control*/
æC

æKY __rHScroll
æFr SIOW.h
æT #define
æD #define __rHScroll 20001 /*horizontal scrollbar control*/
æC

æKY __kErrStrings
æFr SIOW.h
æT #define
æD #define __kErrStrings 20000 /*error string list*/
æC


æKY siow.r
æKL
 'DITL'__rAboutAlert
'DITL'__rUserAlert
'pzza'
AppleMenu
BNDL
CREATOR
CREATOR (0)
DITL
EditMenu
FCREATOR
FileMenu
FontMenu
FREF
ICN#
kErrStrings
MBAR
pzza
rAboutAlert
rDocWindow
rHScroll
rSaveAlert
rUserAlert
rVScroll
SIZE
type CREATOR
WindowHeight
WindowWidth

æKY CREATOR
æFr siow.r
æT #define
æD #include "systypes.r"
#include "types.r"

#include "SIOW.h"

#ifndef CREATOR
     #define CREATOR 'siow'
#endif
æC

æKY FCREATOR
æFr siow.r
æT #define
æD #ifndef FCREATOR
     #define FCREATOR 'MPS '
#endif
æC

æKY pzza
æFr siow.r
æT
æD
type 'pzza' {
    literal longint;
};
æC

æKY 'pzza'
æFr siow.r
æT
æD
resource 'pzza' (128, purgeable) {
    FCREATOR;
};
æC

æKY MBAR
æFr siow.r
æT
æD
/* we use an MBAR resource to conveniently load all the menus */

resource 'MBAR' (__rMenuBar, preload) {
    { __mApple, __mFile, __mEdit, __mFont /*, __mSize */};      /* five menus */
};
æC

æKY AppleMenu
æFr siow.r
æT
æD
resource 'MENU' (__mApple, preload) {
    __mApple, textMenuProc,
    0b1111111111111111111111111111101,  /* disable dashed line, enable About and DAs */
    enabled, apple,
    {
        "About S I O W\311",
            noicon, nokey, nomark, plain;
        "-",
            noicon, nokey, nomark, plain
    }
};
æC

æKY FileMenu
æFr siow.r
æT
æD
resource 'MENU' (__mFile, preload) {
    __mFile, textMenuProc,
    0b000000000000000000000000000000,   /* enable Quit only, program enables others */
    enabled, "File",
    {
        "New",
            noicon, "N", nomark, plain;
        "Open",
            noicon, "O", nomark, plain;
        "-",
            noicon, nokey, nomark, plain;
        "Close",
            noicon, "W", nomark, plain;
        "Save",
            noicon, "S", nomark, plain;
        "Save As\311",
            noicon, nokey, nomark, plain;
        "-",
            noicon, nokey, nomark, plain;
        "Page Setup\311",
            noicon, nokey, nomark, plain;
        "Print\311",
            noicon, nokey, nomark, plain;
        "-",
            noicon, nokey, nomark, plain;
        "Quit",
            noicon, "Q", nomark, plain
    }
};
æC

æKY EditMenu
æFr siow.r
æT
æD
resource 'MENU' (__mEdit, preload) {
    __mEdit, textMenuProc,
    0b0000000000000000000000000000000,  /* disable everything, program does the enabling */
    enabled, "Edit",
     {
        "Undo",
            noicon, "Z", nomark, plain;
        "-",
            noicon, nokey, nomark, plain;
        "Cut",
            noicon, "X", nomark, plain;
        "Copy",
            noicon, "C", nomark, plain;
        "Paste",
            noicon, "V", nomark, plain;
        "Clear",
            noicon, nokey, nomark, plain
    }
};
æC

æKY FontMenu
æFr siow.r
æT
æD
resource 'MENU' (__mFont, preload) {
    __mFont, textMenuProc,
    0b1111111111111111111111111111111,  /* enable everything */
    enabled, "Font",
     {
     }
};
æC

æKY rAboutAlert
æFr siow.r
æT
æD
/* this ALRT and DITL are used as an About screen */

resource 'ALRT' (__rAboutAlert, purgeable) {
    {66, 58, 344, 396}, __rAboutAlert, {
        OK, visible, silent;
        OK, visible, silent;
        OK, visible, silent;
        OK, visible, silent
    };
};
æC

æKY  'DITL'__rAboutAlert
æFr siow.r
æT
æD
resource 'DITL' (__rAboutAlert, purgeable) {
    {   /* array DITLarray: 8 elements */
        /* [1] */
        {233, 144, 253, 224},
        Button {
            enabled,
            "OK"
        },
        /* [2] */
        {8, 72, 23, 264},
        StaticText {
            disabled,
            "Simple Input/Output Window"
        },
        /* [3] */
        {56, 24, 71, 337},
        StaticText {
            disabled,
            "Copyright ©Apple Computer, Inc. 1989-1990 "
        },
        /* [4] */
        {80, 108, 96, 244},
        StaticText {
            disabled,
            "Brought to you by..."
        },
        /* [5] */
        {109, 132, 134, 229},
        StaticText {
            disabled,
            "\"PZZA SLT\""
        },
        /* [6] */
        {176, 56, 200, 289},
        StaticText {
            disabled,
            "Roger, Russ, Landon, Ira & Munch"
        },
        /* [7] */
        {152, 24, 170, 212},
        StaticText {
            disabled,
            "Special Thanks to..."
        },
        /* [8] */
        {32, 152, 47, 200},
        StaticText {
            disabled,
            "(SIOW)"
        }
    }
};
æC

æKY rUserAlert
æFr siow.r
æT
æD
/* this ALRT and DITL are used as an error screen */

resource 'ALRT' (__rUserAlert, purgeable) {
    {40, 20, 150, 260},
    __rUserAlert,
    { /* array: 4 elements */
        /* [1] */
        OK, visible, silent,
        /* [2] */
        OK, visible, silent,
        /* [3] */
        OK, visible, silent,
        /* [4] */
        OK, visible, silent
    }
};
æC

æKY 'DITL'__rUserAlert
æFr siow.r
æT
æD
resource 'DITL' (__rUserAlert, purgeable) {
    { /* array DITLarray: 3 elements */
        /* [1] */
        {80, 150, 100, 230},
        Button {
            enabled,
            "OK"
        },
        /* [2] */
        {10, 60, 60, 230},
        StaticText {
            disabled,
            "Error. ^0."
        },
        /* [3] */
        {8, 8, 40, 40},
        Icon {
            disabled,
            2
        }
    }
};


æC

æKY WindowHeight
æFr siow.r
æT #define
æD #define WindowHeight     286
æC

æKY WindowWidth
æFr siow.r
æT #define
æD #define WindowWidth      480
æC

æKY rDocWindow
æFr siow.r
æT
æD
resource 'WIND' (__rDocWindow, preload, purgeable) {
    {0, 0, WindowHeight, WindowWidth},
    zoomDocProc, invisible, noGoAway, 0x0, "untitled"
};
æC

æKY rVScroll
æFr siow.r
æT
æD
resource 'CNTL' (__rVScroll, preload, purgeable) {
    {-1, WindowWidth-15, WindowHeight-14, WindowWidth+1},
    0, invisible, 0, 0, scrollBarProc, 0, ""
};
æC

æKY rHScroll
æFr siow.r
æT
æD
resource 'CNTL' (__rHScroll, preload, purgeable) {
    {WindowHeight-15, -1, WindowHeight+1, WindowWidth-14},
    0, invisible, 0, 0, scrollBarProc, 0, ""
};
æC

æKY kErrStrings
æFr siow.r
æT
æD
resource 'STR#' (__kErrStrings, purgeable) {
    {
    "You must run on 512Ke or later";
    "Application Memory Size is too small";
    "Not enough memory to run SIOW";
    "Not enough memory to do Cut";
    "Cannot do Cut";
    "Cannot do Copy";
    "Cannot exceed 32,000 characters with Paste";
    "Not enough memory to do Paste";
    "Cannot create window";
    "Cannot exceed 32,000 characters";
    "Cannot do Paste"
    "Font not found"
    }
};
æC

æKY SIZE
æFr siow.r
æT
æD
/* here is the quintessential MultiFinder friendliness device, the SIZE resource */

resource 'SIZE' (-1) {
    dontSaveScreen,
    acceptSuspendResumeEvents,
    enableOptionSwitch,
    canBackground,              /* we can background; we don't currently, but our sleep value */
                                /* guarantees we don't hog the Mac while we are in the background */
    multiFinderAware,           /* this says we do our own activate/deactivate; don't fake us out */
    backgroundAndForeground,    /* this is definitely not a background-only application! */
    dontGetFrontClicks,         /* change this is if you want "do first click" behavior like the Finder */
    ignoreChildDiedEvents,      /* essentially, I'm not a debugger (sub-launching) */
    not32BitCompatible,         /* this app should not be run in 32-bit address space */
    reserved,
    reserved,
    reserved,
    reserved,
    reserved,
    reserved,
    reserved,
    __kPrefSize * 1024,
    __kMinSize * 1024
};
æC

æKY type CREATOR
æFr siow.r
æT
æD
type CREATOR as 'STR ';
æC

æKY CREATOR (0)
æFr siow.r
æT
æD
resource CREATOR (0) {
    "MultiFinder-Aware Simple Input/Output Window (SIOW)"
};
æC

æKY BNDL
æFr siow.r
æT
æD
resource 'BNDL' (128) {
    CREATOR,
    0,
    {
        'ICN#',
        {
            0, 128
        },
        'FREF',
        {
            0, 128
        }
    }
};

æC

æKY FREF
æFr siow.r
æT
æD
resource 'FREF' (128) {
    'APPL',
    0,
    ""
};
æC

æKY ICN#
æFr siow.r
æT
æD
resource 'ICN#' (128) {
    {   /* array: 2 elements */
        /* [1] */
        $"0000 0000 0000 0000 0010 4100 0010 2200"
        $"0020 2200 0020 2100 0020 4100 0010 4200"
        $"0010 4200 0010 2200 0020 2100 0020 0100"
        $"00FF FF00 03FF FFE0 0791 03F0 0ED1 0E7C"
        $"1C31 321C 380D C10E 3FFF FFFE 3003 C106"
        $"380D 300E 1E31 0E3C 1FC1 01F8 07FF FFE0"
        $"00FF FE00",
        /* [2] */
        $"0000 0000 0000 0000 0010 4100 0010 2200"
        $"0020 2200 0020 2100 0020 4100 0010 4200"
        $"0010 4200 0010 2200 0020 2100 0020 0100"
        $"00FF FF00 03FF FFE0 07FF FFF0 0FFF FFFC"
        $"1FFF FFFC 3FFF FFFE 3FFF FFFE 3FFF FFFE"
        $"3FFF FFFE 1FFF FFFC 1FFF FFF8 07FF FFE0"
        $"00FF FE00"
    }
};
æC

æKY rSaveAlert
æFr siow.r
æT
æD
resource 'ALRT' (__rSaveAlert, preload) {
    {72, 64, 212, 372},
    __rSaveAlert,
    {   /* array: 4 elements */
        /* [1] */
        OK, visible, silent,
        /* [2] */
        OK, visible, silent,
        /* [3] */
        OK, visible, silent,
        /* [4] */
        OK, visible, silent
    }
};
æC

æKY DITL
æFr siow.r
æT
æD
resource 'DITL' (__rSaveAlert, preload) {
    {   /* array DITLarray: 4 elements */
        /* [1] */
        {58, 25, 76, 99},
        Button {
            enabled,
            "Yes"
        },
        /* [2] */
        {86, 25, 104, 99},
        Button {
            enabled,
            "No"
        },
        /* [3] */
        {12, 20, 45, 277},
        StaticText {
            disabled,
            "Save changes before closing?"
        },
        /* [4] */
        {86, 195, 104, 269},
        Button {
            enabled,
            "Cancel"
        }
    }
};
æC


æKY SysTypes.r
æKL
 ppcc
'KCAP'
bold
colonSymbol
commaSymbol
CommFlags
condense
dollarsignSymbol
DRVR
extend
FileSpec
FileSpecFlags
finf
fld#
FOND
FONT
FRSV
FWID
gmcd
insc
INTL (0)
INTL (1)
it10
italic
itl1
itl2
itl4
itlb
itlc
itlk
itlm
KCHR
KMAP
KSWP
Language
mach
mcky
mitq
mppc
NFNT
nrct
outline
periodSymbol
Region
resf
ROv#
RsrcSpecFlags
Script
scrn
semicolonSymbol
shadow
slashSymbol
snd
underline
vers

æKY periodSymbol
æFr SysTypes.r
æT #define
æD #define periodSymbol         "."
æC

æKY commaSymbol
æFr SysTypes.r
æT #define
æD #define commaSymbol          ","
æC

æKY semicolonSymbol
æFr SysTypes.r
æT #define
æD #define semicolonSymbol      ";"
æC

æKY dollarsignSymbol
æFr SysTypes.r
æT #define
æD #define dollarsignSymbol     "$"
æC

æKY slashSymbol
æFr SysTypes.r
æT #define
æD #define slashSymbol          "/"
æC

æKY colonSymbol
æFr SysTypes.r
æT #define
æD #define colonSymbol          ":"
æC

æKY Script
æFr SysTypes.r
æT #define
æD #define Script      smRoman, smJapanese, smTradChinese, smKorean,       \
                    smArabic, smHebrew, smGreek, smCyrillic, smRSymbol, \
                    smDevanagari, smGurmukhi, smGujarati, smOriya,      \
                    smBengali, smTamil, smTelugu, smKannada,            \
                    smMalayalam, smSinhalese, smBurmese, smKhmer,       \
                    smThai, smLaotian, smGeorgian, smArmenian,          \
                    smSimpChinese, smTibetan, smMongolian, smGeez,      \
                    smSlavic, smVietnamese, smExtArabic, smUninterp     \

æC

æKY Language
æFr SysTypes.r
æT #define
æD #define Language    langEnglish, langFrench, langGerman, langItalian,   \
                    langDutch, langSwedish, langSpanish, langDanish,    \
                    langPortuguese, langNorwegian, langHebrew,          \
                    langJapanese, langArabic, langFinnish, langGreek,   \
                    langIcelandic, langMaltese, langTurkish,            \
                    langCroatian, langTradChinese, langUrdu,            \
                    langHindi, langThai, langKorean, langLithuanian,    \
                    langPolish, langHungarian, langEstonian,            \
                    langLettish, langLappish, langFaeroese,             \
                    langFarsi, langRussian, langSimpChinese,            \
                    langFlemish, langIrish, langAlbanian, langRomanian, \
                    langCzech, langSlovak, langSlovenian, langYiddish,  \
                    langSerbian, langMacedonian, langBulgarian,         \
                    langUkrainian, langByelorussian, langUzbek,         \
                    langKazakh, langAzerbaijani, langAzerbaijanAr,      \
                    langArmenian, langGeorgian, langMoldavian,          \
                    langKirghiz, langTajiki, langTurkmen,               \
                    langMongolian, langMongolianCyr, langPashto,        \
                    langKurdish, langKashmiri, langSindhi, langTibetan, \
                    langNepali, langSanskrit, langMarathi, langBengali, \
                    langAssamese, langGujarati, langPunjabi, langOriya, \
                    langMalayalam, langKannada, langTamil, langTelugu,  \
                    langSinhalese, langBurmese, langKhmer, langLao,     \
                    langVietnamese, langIndonesian, langTagalog,        \
                    langMalayRoman, langMalayArabic, langAmharic,       \
                    langTigrinya, langGalla, langSomali, langSwahili,   \
                    langRuanda, langRundi, langChewa, langMalagasy,     \
                    langEsperanto, langUnspecified = 32767              \

æC

æKY Region
æFr SysTypes.r
æT #define
æD #define Region      verUS, verFrance, verBritain, verGermany,           \
                    verItaly, verNetherlands, verBelgiumLux,            \
                    verFrBelgiumLux = 6, verSweden, verSpain,           \
                    verDenmark, verPortugal, verFrCanada, verNorway,    \
                    verIsrael, verJapan, verAustralia, verArabia,       \
                    verArabic=16, verFinland, verFrSwiss, verGrSwiss,   \
                    verGreece, verIceland, verMalta, verCyprus,         \
                    verTurkey, verYugoslavia, verYugoCroatian = 25,     \
                    verIndia = 33, verIndiaHindi = 33, verPakistan,     \
                    verLithuania = 41, verPoland, verHungary,           \
                    verEstonia, verLatvia, verLapland, verFaeroeIsl,    \
                    verIran, verRussia, verIreland = 50, verKorea,      \
                    verChina, verTaiwan, verThailand                    \

æC

æKY bold
æFr SysTypes.r
æT #define
æD #define bold             1
æC

æKY italic
æFr SysTypes.r
æT #define
æD #define italic           2
æC

æKY underline
æFr SysTypes.r
æT #define
æD #define underline        4
æC

æKY outline
æFr SysTypes.r
æT #define
æD #define outline          8
æC

æKY shadow
æFr SysTypes.r
æT #define
æD #define shadow          16
æC

æKY condense
æFr SysTypes.r
æT #define
æD #define condense        32
æC

æKY extend
æFr SysTypes.r
æT #define
æD #define extend          64
æC

æKY DRVR
æFr SysTypes.r
æT
æD
/*----------------------------DRVR • Driver---------------------------------------------*/
type 'DRVR' {
        boolean = 0;
        boolean         dontNeedLock, needLock;                 /* lock drvr in memory  */
        boolean         dontNeedTime, needTime;                 /* for periodic action  */
        boolean         dontNeedGoodbye, needGoodbye;           /* call before heap reinit*/
        boolean         noStatusEnable, statusEnable;           /* responds to status   */
        boolean         noCtlEnable, ctlEnable;                 /* responds to control  */
        boolean         noWriteEnable, writeEnable;             /* responds to write    */
        boolean         noReadEnable, readEnable;               /* responds to read     */
        byte = 0;
        integer;                                                /* driver delay         */
        unsigned hex integer;                                   /* desk acc event mask  */
        integer;                                                /* driver menu          */
        unsigned hex integer;                                   /* offset to open       */
        unsigned hex integer;                                   /* offset to prime      */
        unsigned hex integer;                                   /* offset to control    */
        unsigned hex integer;                                   /* offset to status     */
        unsigned hex integer;                                   /* offset to close      */
        pstring;                                                /* driver name          */
        hex string;                                             /* driver code          */
};
æC

æKY finf
æFr SysTypes.r
æT
æD /*----------------------------finf • Font Family Description----------------------------*/
type 'finf' {
        integer = $$CountOf(Fonts);                             /* # of fonts           */
        array Fonts {
            integer;                                            /* Font Number          */
            unsigned hex integer    plain;                      /*      Font Style      */
            integer;                                            /*      Font Size       */
        };
};
æC

æKY FOND
æFr SysTypes.r
æT
æD /*----------------------------FOND • Font Family Description----------------------------*/
/* Note: this FOND resource definition only works when the tables at the end of the
         resource are in this order:    1 - Family Character-Width Table
                                        2 - Style Mapping Table
                                        3 - Kerning Tables
*/
type 'FOND' {
        /* Flags Word */
        boolean     proportionalFont, fixedWidthFont;
        boolean     useFractWidthTable, dontUseFractWidthTable;
        boolean     computeFixedPointExtra, useIntegerExtra;
        boolean     useFractEnable, ignoreFractEnable;
        boolean     canAdjustCharSpacing, dontAdjustCharSpacing;
        unsigned hex bitstring[9] = 0;                          /* Reserved             */
        boolean     noCharWidthTable, hasCharWidthTable;
        boolean     noImageHeightTable, hasImageHeightTable;

        integer;                                                /* Family ID number     */
    First:
        integer;                                                /* first char           */
    Last:
        integer;                                                /* last char            */
        integer;                                                /* Ascent               */
        integer;                                                /* Descent              */
        integer;                                                /* Leading              */
        integer;                                                /* Width Max            */
    WidthOffset:
        unsigned hex longint = WidthTable[1] >> 3;              /* Width table offset   */
    KerningOffset:
        unsigned hex longint = KerningTable[1] >> 3;            /* Kerning table offset */
    StyleMapOffset:
        unsigned hex longint = StyleTable[1] >> 3;              /* Style map offset     */
        integer;                                                /* reserved             */
        integer;                                                /* ex wid bold          */
        integer;                                                /* ex wid italic        */
        integer;                                                /* ex wid underline     */
        integer;                                                /* ex wid outline       */
        integer;                                                /* ex wid shadow        */
        integer;                                                /* ex wid condensed     */
        integer;                                                /* ex wid extended      */
        integer;                                                /* reserved             */
        longint;                                                /* reserved for intl    */
    Version:
        integer;                                                /* version              */

        /* Font Association Table */
        integer = $$CountOf(FontEntries)-1;                     /* # of font entries    */
        wide array FontEntries {
            integer;                                            /* Font size            */
            unsigned hex integer    plain;                      /*      Font Style      */
            integer;                                            /* Resource ID of FONT  */
        };
        /*  */
        array [$$Word(Version) == 2] {
    OffsetTableStart:
            integer = $$CountOf(OffsetTable) - 1;
            array OffsetTable {
                longint = (BBoxStart[1] - OffsetTableStart[1]) >> 3;
            };
            /* Font Bounding Box Table */
    BBoxStart:
            integer = $$CountOf(BBoxTable) - 1;
            wide array BBoxTable {
                fill bit[9];                                    /* Reserved             */
                Boolean     noExtendedStyle, EXTENDEDstyle;     /* Extended style       */
                Boolean     noCondensedStyle, CONDENSEDstyle;   /* Condensed style      */
                Boolean     noShadowStyle, SHADOWstyle;         /* Shadow style         */
                Boolean     noOutlineStyle, OUTLINEstyle;       /* Outline style        */
                Boolean     noUnderline, UNDERLINEstyle;        /* Underline style      */
                Boolean     noItalicStyle, ITALICstyle;         /* Italic style         */
                Boolean     noBoldStyle, BOLDstyle;             /* Bold style           */
                Rect;
            };
        };

        /* Family Character-Width Table */
        /* This outer array below handles the case when the width table offset (WidthOffset:)
           is zero. */
        array [$$Long(WidthOffset) != 0] {
    WidthTable:
            integer = $$CountOf(WidthTable) - 1;                /* # of width tables    */
            wide array WidthTable {
                fill bit[9];                                    /* Reserved             */
                Boolean     noExtendedStyle, EXTENDEDstyle;     /* Extended style       */
                Boolean     noCondensedStyle, CONDENSEDstyle;   /* Condensed style      */
                Boolean     noShadowStyle, SHADOWstyle;         /* Shadow style         */
                Boolean     noOutlineStyle, OUTLINEstyle;       /* Outline style        */
                Boolean     noUnderline, UNDERLINEstyle;        /* Underline style      */
                Boolean     noItalicStyle, ITALICstyle;         /* Italic style         */
                Boolean     noBoldStyle, BOLDstyle;             /* Bold style           */

                wide array [$$Word(Last) - $$Word(First) + 3] {
                    unsigned hex integer;                       /* Width of character   */
                };
            };
        };

        /* Style Mapping Table */
        /* This outer array below handles the case when the width table offset (WidthOffset:)
           is zero. */
        array [$$Long(StyleMapOffset) != 0] {
    StyleTable:
            unsigned hex integer;                               /* Font class           */
    CharCodeOffset:
            unsigned hex longint =                              /* Encoding table offset*/
                (CharCodeTable[1,1] - StyleTable[1]) / 8 * (CharCodeTable[1,1] != 0);
            fill long;                                          /* Reserved             */
            array [48] {
                byte;
            };
            /* Style Name Table */
            integer = $$CountOf(StyleNames);                    /* Number of strings    */
            pstring;                                            /* Full base font name  */
            array StyleNames {
                pstring;                                        /* Style suffix names   */
            };

            /* Character Set Encoding Table */
            /* This outer array below handles the case when the character set encoding
               offset is zero (CharCodeOffset:) */
            array [$$Long(CharCodeOffset[1]) != 0] {
    CharCodeTable:
                integer = $$CountOf(CharacterCodes);            /* Number of entries    */
                wide array CharacterCodes {
                    char;                                       /* Character code       */
                    pstring;                                    /* Char name string     */
                };
            };
        };

        /* Kerning Tables */
        /* This outer array below handles the case when the kerning table offset
           (KerningOffset:) is zero. */
        array [$$Long(KerningOffset) != 0] {
            /* Kerning Tables */
    KerningTable:
            integer = $$CountOf(KerningTables) - 1;             /* Number of tables     */
            wide array KerningTables {
                fill bit[9];                                    /* Reserved             */
                Boolean     noExtendedStyle, EXTENDEDstyle;     /* Extended style       */
                Boolean     noCondensedStyle, CONDENSEDstyle;   /* Condensed style      */
                Boolean     noShadowStyle, SHADOWstyle;         /* Shadow style         */
                Boolean     noOutlineStyle, OUTLINEstyle;       /* Outline style        */
                Boolean     noUnderline, UNDERLINEstyle;        /* Underline style      */
                Boolean     noItalicStyle, ITALICstyle;         /* Italic style         */
                Boolean     noBoldStyle, BOLDstyle;             /* Bold style           */
                integer = $$CountOf(KerningTableEntry);         /* # of entries         */
                wide array KerningTableEntry {
                    char;                                       /* first char of pair   */
                    char;                                       /* second char of pair  */
                    unsigned hex integer;                       /* kerning offset       */
                };
            };
        };
};
æC

æKY FONT
æFr SysTypes.r
æT
æD /*----------------------------FONT • Font Description-----------------------------------*/
/* PROBLEMS: the offset to the offset/width table has been changed to a longint, with the
             high word stored in the neg descent field (if its not -1).  Rez can't handle
             this. */
type 'FONT' {
        /* Font Type Flags */
FontType:
        boolean = 1;                                            /* Reserved             */
        boolean     doExpandFont, dontExpandFont;
        boolean     proportionalFont, fixedWidthFont;
        boolean = 1;                                            /* Reserved             */
        unsigned bitstring[2] = 0;                              /* Reserved             */
        boolean     blackFont, colorFont;
        boolean     notSynthetic, isSynthetic;
        boolean     nofctbRsrc, hasfctbRsrc;
        unsigned bitstring[3] = 0;                              /* Reserved             */
        unsigned bitstring[2]   oneBit, twoBit,                 /* Font depth           */
                                fourBit, eightBit;
        boolean     noCharWidthTable, hasCharWidthTable;
        boolean     noImageHeightTable, hasImageHeightTable;

    FirstChar:
        integer;                                                /* first char           */
    LastChar:
        integer;                                                /* last char            */
        integer;                                                /* width max            */
        integer;                                                /* kern max             */
        integer;                                                /* neg descent          */
        integer;                                                /* font rect width      */
    Height:
        integer;                                                /* font rect height     */
    Offset:
        unsigned integer = ((WidthTable-Offset)/16);            /* offset to off/wid tab*/
        integer;                                                /* ascent               */
        integer;                                                /* descent              */
        integer;                                                /* leading              */
    RowWords:
        integer;                                                /* row width (in words) */

        /* Tables */
        /* Bit image */
        hex string [($$Word(RowWords) <<($$BitField(FontType, 12, 2)
            & 3) + 1) * $$Word(Height)];

        /* Location Table */
        array [$$Word(LastChar) - $$Word(FirstChar) + 3] {
            integer;
        };

        /* Offset/Width Table */
    WidthTable:
        array [$$Word(LastChar) - $$Word(FirstChar) + 3] {
            integer;
        };

        /* Optional Character Width Table */
        Array [($$Word(FontType) & 0x0002) != 0] {
            array [$$Word(LastChar) - $$Word(FirstChar) + 3] {
                integer;
            };
        };

        /* Optional Image Height Table */
        Array [($$Word(FontType) & 0x0001) != 0] {
            array [$$Word(LastChar) - $$Word(FirstChar) + 3] {
                integer;
            };
        };
};
æC

æKY FWID
æFr SysTypes.r
æT
æD /*----------------------------FWID • Font Width Table-----------------------------------*/
type 'FWID' {
        unsigned hex integer;                                   /* Font type            */
        integer;                                                /* first char           */
        integer;                                                /* last char            */
        integer;                                                /* width max            */
        integer;                                                /* kern max             */
        integer;                                                /* neg descent          */
        integer;                                                /* font rect width      */
        integer;                                                /* font rect height     */
        unsigned hex integer;                                   /* offset to off/wid tab*/
        integer;                                                /* ascent               */
        integer;                                                /* descent              */
        integer;                                                /* leading              */
        integer;                                                /* row width (in words) */
        wide array {                                            /* offset/width table   */
            byte;                                               /* char offset          */
            byte;                                               /* char width           */
        };
};
æC

æKY gmcd
æFr SysTypes.r
æT
æD /*----------------------------gmcd • Guard Mechanism for Compression/Decompression------*/
type 'gmcd' {
        integer = $$Countof(TypeIDArray);
        array TypeIDArray {
            literal longint;                                    /* resource type */
            integer;                                            /* resource ID */
        };
};
æC

æKY CommFlags
æFr SysTypes.r
æT #define
æD #define CommFlags                                                                          \
        boolean     noDelRemove, delRemove;             /* Remove file if remove clicked*/ \
        boolean     noDelInstall, delInstall;           /* Delete target before copy    */ \
        boolean     noCopy, copy;                       /* Copy file to destination     */ \
        fill bit[3];                                    /* Reserved                     */ \
        boolean     doReplace, dontReplace;             /* Replace                      */ \
        fill bit[1];                                    /* Reserved                     */ \
        boolean     old, noOld;                         /* Type & creator need not match*/ \
        boolean     noUpdateOnly, updateOnly            /* Only update if target exists */

æC

æKY FileSpecFlags
æFr SysTypes.r
æT #define
æD #define FileSpecFlags                                                                      \
        CommFlags;                                                                         \
        boolean     noRsrcFork, rsrcFork;               /* Apply operation to rsrc fork */ \
        boolean     noDataFork, dataFork;               /* Apply operation to data fork */ \
        boolean     needExist, needNotExist;            /* File need not exist          */ \
        boolean     noCrDate, crDate;                   /* Creation date must match     */ \
        boolean     noTypeCr, typeCr;                   /* Type and creator must match  */ \
        bitstring[1] = 1                                /* Indicates file specification */

æC

æKY RsrcSpecFlags
æFr SysTypes.r
æT #define
æD #define RsrcSpecFlags                                                                      \
        CommFlags;                                                                         \
        fill bit;                                       /* Reserved                     */ \
        boolean     noEvenIf, evenIf;                   /* Do it even if rsrc protected */ \
        boolean     needExist, needNotExist;            /* Rsrc need not exist          */ \
        fill bit;                                       /* Reserved                     */ \
        boolean noByID, byID;                           /* Use name or id to find rsrc  */ \
        bitstring[1] = 0                                /* Indicates rsrc specification */

æC

æKY FileSpec
æFr SysTypes.r
æT #define
æD #define FileSpec                                                                           \
        FileSpecFlags;                                  /* FileSpec Flags               */ \
        literal longint;                                /* File Type                    */ \
        literal longint;                                /* File Creator                 */ \
        unsigned hex longint;                           /* Creation Date, use              \
                                                           $$DateToLongInt() to read in    \
                                                           the date.                    */ \
        fill long[3];                                   /* Handle, FDelSize, FAddSize   */ \
        pstring;                                        /* File Name                    */ \
        align word

æC

æKY insc
æFr SysTypes.r
æT
æD type 'insc' {
        switch {
            case format0:
                key integer = 0;                                /* Script Format        */
                hex integer = 0;                                /* Script Flags         */
                pstring;                                        /* Script Name          */
                align word;
                wstring;                                        /* Script Help          */
                align word;
                unsigned integer = $$CountOf(FileList);         /* File List            */
                wide array FileList {
                    FileSpec;                                   /* File Spec            */
                };
                unsigned integer = $$CountOf(ResFileList);      /* Resource File List   */
                wide array ResFileList {
                    FileSpec;                                   /* Target File Spec     */
                    integer = $$CountOf(SrcFileList);           /* Source File List     */
                    wide array SrcFileList {
                        FileSpec;                               /* Source File Spec     */
                        unsigned integer = $$CountOf(ResList);  /* Resource List        */
                        wide array ResList {
                            RsrcSpecFlags;                      /* Resource Spec Flags  */
                            literal longint;                    /* Resource Type        */
                            integer;                            /* Source ID            */
                            integer;                            /* Target ID            */
                            fill word[2];                       /* CRC/Version, Filler1 */
                            fill long[3];                       /* Filler2, RDelSize,
                                                                    RAddSize            */
                            pstring;                            /* Resource Name        */
                            align word;
                            integer = 0;                        /* Previous CRC List    */
                        };
                    };
                };
                integer = 0;                                    /* Disk Blocks          */

            case format1:
                key integer = 1;                                /* Script Format        */
                hex integer = 0;                                /* Script Flags         */
                pstring;                                        /* Script Name          */
                align word;
                wstring;                                        /* Script Help          */
                align word;
                unsigned integer = $$CountOf(FileList);         /* File List            */
                wide array FileList {
                    FileSpec;                                   /* File Spec            */
                };
                unsigned integer = $$CountOf(ResFileList);      /* Resource File List   */
                wide array ResFileList {
                    FileSpec;                                   /* Target File Spec     */
                    integer = $$CountOf(SrcFileList);           /* Source File List     */
                    wide array SrcFileList {
                        FileSpec;                               /* Source File Spec     */
                        unsigned integer = $$CountOf(ResList);  /* Resource List        */
                        wide array ResList {
                            RsrcSpecFlags;                      /* Resource Spec Flags  */
                            literal longint;                    /* Resource Type        */
                            integer;                            /* Source ID            */
                            integer;                            /* Target ID            */
                            fill word[2];                       /* CRC/Version, Filler1 */
                            fill long[3];                       /* Filler2, RDelSize,
                                                                   RAddSize             */
                            pstring;                            /* Resource Name        */
                            align word;
                            integer = 0;                        /* Previous CRC List    */
                        };
                    };
                };
                unsigned integer;                               /* Boot Block Version   */
                unsigned integer;                               /* Number of Open Files */
                unsigned integer;                               /* Number of Events     */
                unsigned hex longint;                           /* Sys Heap Size 128K   */
                unsigned hex longint;                           /* Sys Heap Size 256K   */
                unsigned hex longint;                           /* Sys Heap Size 512K   */
          };
};
æC

æKY INTL (0)
æFr SysTypes.r
æT
æD /*----------------------------INTL (0) • International Formatting Information-----------*/
type 'INTL' (0) {
        char        period = periodSymbol;                      /* decimal pt sep       */
        char        comma = commaSymbol;                        /* thousands sep        */
        char        semicolon = semicolonSymbol;                /* list sep             */
        char        dollarsign = dollarsignSymbol;              /* currSym1             */
        char;                                                   /* currSym2             */
        char;                                                   /* currSym3             */

        /* currFmt */
        boolean     noLeadZero, leadingZero;                    /* leading unit zero    */
        boolean     noTrailingZero, trailingZero;               /* trailing dec zero    */
        boolean     paren, minusSign;                           /* negative rep         */
        boolean     trails, leads;                              /* curr sym position    */
        fill bit[4];                                            /* not used             */
        byte        monDayYear, dayMonYear, yearMonDay,         /* dateOrder            */
                    monYearDay, dayYearMon, yearDayMon;

        /* shrtDateFmt */
        boolean     noCentury, century;                         /* century incl         */
        boolean     noMonthLeadZero, monthLeadZero;             /* mon lead zero        */
        boolean     noDayLeadZero, dayLeadZero;                 /* day lead zero        */
        fill bit[5];                                            /* filler               */
        char        slash = slashSymbol;                        /* date sep             */
        byte        twentyFourHour, twelveHourZeroCycle,        /* timeCycle            */
                    twelveHour = 255;

        /* timeFmt */
        boolean     noHoursLeadZero, hoursLeadZero;             /* hours lead zero      */
        boolean     noMinutesLeadZero, minutesLeadZero;         /* min lead zero        */
        boolean     noSecondsLeadZero, secondsLeadZero;         /* sec lead zero        */
        fill bit[5];                                            /* filler               */
        string[4];                                              /* mornStr              */
        string[4];                                              /* eveStr               */
        char;                                                   /* timeSep              */
        char;                                                   /* time1Stuff           */
        char;                                                   /* time2Stuff           */
        char;                                                   /* time3Stuff           */
        char;                                                   /* time4Stuff           */
        char;                                                   /* time5Stuff           */
        char;                                                   /* time6Stuff           */
        char;                                                   /* time7Stuff           */
        char;                                                   /* time8Stuff           */
        byte        standard, metric = 255;                     /* metricSys            */
        byte        Region;                                     /* INTL0 region         */
        byte;                                                   /* version              */
};
æC

æKY it10
æFr SysTypes.r
æT
æD /*----------------------------itl0 • International Formatting Information---------------*/
type 'itl0' as 'INTL' (0);
æC

æKY INTL (1)
æFr SysTypes.r
æT
æD /*----------------------------INTL (1) • International Date/Time Information------------*/
type 'INTL' (1) {
        /* Day names */
        array [7] {
            pstring[15];                                        /* Sunday, Monday...    */
        };

        /* Month names */
        array [12] {
            pstring[15];                                        /* January, February... */
        };

        byte        dayName, none=255;                          /* suppressDay          */
        byte        dayMonYear, monDayYear = 255;               /* longDate format      */
        byte        noDayLeadZero, dayLeadZero = 255;           /* dayLeading0          */
        byte;                                                   /* abbrLen              */
        string[4];                                              /* st0                  */
        string[4];                                              /* st1                  */
        string[4];                                              /* st2                  */
        string[4];                                              /* st3                  */
        string[4];                                              /* st4                  */
        byte        Region;                                     /* INTL1 region         */
        byte;                                                   /* version              */
        hex string  DefaultReturn = "\$4E\$75";                 /* local routine - If
                                                                   you have one, use
                                                                   $$Resource to insert
                                                                   code here.  Otherwise,
                                                                   you must have a 68000
                                                                   return instruction.
                                                                   Use DefaultReturn.   */
};
æC

æKY itl1
æFr SysTypes.r
æT
æD /*----------------------------itl1 • International Date/Time Information----------------*/
/* This is separated out because it is changed for 7.0 to be different than 'INTL' (1). */
/* The old INTL (1) format had a local routine field at the end. This was to be used    */
/* for localized string sorting code. However, for the last 4 years, string sorting has */
/* been handled with the 'itl2' resource, and the local routine field has been ignored. */
/* In most 'itl1' resources, it just contains a single RTS instruction (hex $4E75).     */
/* This field is now used to flag the 7.0 extensions. If it is $4E75, the old format is */
/* assumed. If it is $A89F, the new format is assumed: $A89F is unimplemented trap,     */
/* which would never have occurred as the first instruction in a local routine. Old     */
/* 'itl1' resources with a local routine will be handled correctly by the code, but can */
/* not be Rezzed or DeRezzed with this template. They should be updated to either have  */
/* $4E75 in the local routine field, with nothing else following, or to have $A89F in   */
/* the local routine filed, followed by extended data in the format given below. The    */
/* version field was not used to mark this change because various current 'itl1'        */
/* resources use very different version numbers, including 0, 1, and 128.               */

type 'itl1' {
        /* Day names */
        array [7] {
            pstring[15];                                        /* Sunday, Monday...    */
        };

        /* Month names */
        array [12] {
            pstring[15];                                        /* January, February... */
        };

        byte        dayName, none=255;                          /* suppressDay          */
        byte        dayMonYear, monDayYear = 255;               /* longDate format      */
        byte        noDayLeadZero, dayLeadZero = 255;           /* dayLeading0          */
        byte;                                                   /* abbrLen              */
        string[4];                                              /* st0                  */
        string[4];                                              /* st1                  */
        string[4];                                              /* st2                  */
        string[4];                                              /* st3                  */
        string[4];                                              /* st4                  */
        byte        Region;                                     /* region code          */
        byte;                                                   /* version              */
        switch  {
            case oldFormat:
                key hex integer = $4E75;                        /* old format key       */
            case extFormat:
                key hex integer = $A89F;                        /* extended format key  */
                hex integer;                                    /* version              */
                hex integer;                                    /* format               */
                integer;                                        /* calendar code        */
                unsigned longint = extraDays >> 3;                          /* offset to extraDays table    */
                unsigned longint = (endExtraDays - extraDays) >> 3;         /* length of extraDays table    */
                unsigned longint = extraMonths >> 3;                        /* offset to extraMonths table  */
                unsigned longint = (endExtraMonths - extraMonths) >> 3;     /* length of extraMonths table  */
                unsigned longint = abbrevDays >> 3;                         /* offset to abbrevDays table   */
                unsigned longint = (endAbbrevDays - abbrevDays) >> 3;       /* length of abbrevDays table   */
                unsigned longint = abbrevMonths >> 3;                       /* offset to abbrevMonths table */
                unsigned longint = (endAbbrevMonths - abbrevMonths) >> 3;   /* length of abbrevMonths table */
                unsigned longint = extraSeparators >> 3;                    /* offset to extraSeparators table  */  /*<10>*/
                unsigned longint = (endExtraSeparators - extraSeparators) >> 3; /* len of extraSeparators table */  /*<10>*/
extraDays:
                integer = $$CountOf(extraDaysArray);            /* number of extra days */
                array extraDaysArray {                          /* array of extra names     */
                    pstring;                                    /* extra day name string    */
                };
endExtraDays:
extraMonths:
                integer = $$CountOf(extraMonthArray);           /* number of extra months   */
                array extraMonthArray {                         /* array of extra names     */
                    pstring;                                    /* extra month name string  */
                };
endExtraMonths:
abbrevDays:
                integer = $$CountOf(abbrevDaysArray);           /* number of abbrev days    */
                array abbrevDaysArray {                         /* array of abbrev names    */
                    pstring;                                    /* abbrev day name string   */
                };
endAbbrevDays:
abbrevMonths:
                integer = $$CountOf(abbrevMonthArray);          /* number of abbrev months  */
                array abbrevMonthArray {                        /* array of abbrev names    */
                    pstring;                                    /* abbrev month name string */
                };
endAbbrevMonths:
extraSeparators:
                integer = $$CountOf(extraSeparatorsArray);      /* number of extra separators   */  /*<10>*/
                array extraSeparatorsArray {                    /* array of separator strings   */  /*<10>*/
                    pstring;                                    /* separator string             */  /*<10>*/
                };
endExtraSeparators:
        };
};
æC

æKY itl2
æFr SysTypes.r
æT
æD /*----------------------------itl2 • International String Comparison Package Hooks-----*/
/*
 * Note that this type assumes a particular ordering of code and tables, although
 * that order is not required in order for the resource to be used correctly by
 * the code.
 *
 * There is some ugly stuff at the end, because
 * 1. The itl2 resource has several different formats.
 * 2. The offset to the FindScriptTable is only present in one format: when length
 *    fields exist.
 * 3. Even in that format, the FindScriptTable itself is optional; if it is not
 *    present, the offset to it is 0.
 * 4. The optional FindScriptTable is preceded by the variable-length wrapTable.
 *    To determine the wrapTable length when DeRezzing, we need to use the offset
 *    to FindScriptTable if the offset exists and is nonzero. Otherwise, wrapTable
 *    extends to the end of the resource.
 * The single hex string at the end of the wrapTable is actually represented in
 * three different arrays whose dimensions are logical expressions. For a given
 * format, one of the arrays will have a dimension 1, and the others will have a
 * dimension 0.
 */

type 'itl2' {
        switch {
            case pre604:
                integer = initHook1 >> 3;                           /* init hook offset         */
                integer = fetchHook1 >> 3;                          /* fetch hook offset        */
                integer = vernierHook1 >> 3;                        /* vernier hook offset      */
                integer = projectHook1 >> 3;                        /* project hook offset      */
                bitstring[15] = rsvd1Hook1 >> 4;
                key boolean = 0;
                integer = rsvd2Hook1 >> 3;                          /* rsvd2 hook offset        */
    initHook1:
                hex string [(fetchHook1 - initHook1) >> 3];         /* initHook code            */
    fetchHook1:
                hex string [(vernierHook1 - fetchHook1) >> 3];      /* fetchHook code           */
    vernierHook1:
                hex string [(projectHook1 - vernierHook1) >> 3];    /* vernierHook code         */
    projectHook1:
                hex string [(rsvd1Hook1 - projectHook1) >> 3];      /* projectHook code         */
    rsvd1Hook1:
                hex string [(rsvd2Hook1 - rsvd1Hook1) >> 3];        /* rsvd1Hook code           */
    rsvd2Hook1:
                hex string;                                         /* rsvd2Hook/exitHook code  */
            case atLeast604:
                integer = initHook2 >> 3;                           /* init hook offset         */
                integer = fetchHook2 >> 3;                          /* fetch hook offset        */
                integer = vernierHook2 >> 3;                        /* vernier hook offset      */
                integer = projectHook2 >> 3;                        /* project hook offset      */
                bitstring[15] = -1;
                key boolean = 1;
                integer = rsvd2Hook2 >> 3;                          /* rsvd2 hook offset        */
                integer = typeList >> 3;                            /* TypeList offset          */
                integer = classArray >> 3;                          /* ClassArray offset        */
                integer = upperList >> 3;                           /* UpperList offset         */
                integer = lowerList >> 3;                           /* LowerList offset         */
                integer = upperNoMarkList >> 3;                     /* UpperNoMarkList offset   */
                integer = wordTable >> 3;                           /* WordTable offset         */
                integer = wrapTable >> 3;                           /* WrapTable offset         */
                integer = noMarkList >> 3;                          /* NoMarkList offset        */
                unsigned hex integer;                               /* version number           */
    formatCode:
                switch {
                    case noLengthFields:
                        key integer = 0;                            /* format code              */
    extraHdr:
                        hex string [(initHook2 - extraHdr) >> 3];   /* extra header, if any     */
                    case haveLengthFields:
                        key integer = 1;                            /* format code              */
                        wide array [14] {
                            integer;                                /* length fields            */
                        };
    findScriptTableOffset:
                        integer = findScriptTable[1,1] >> 3;        /* findScriptTable offset   */
                        integer;                                    /* findScriptTable length   */
                };
    initHook2:
                hex string [(fetchHook2 - initHook2) >> 3];         /* initHook code            */
    fetchHook2:
                hex string [(vernierHook2 - fetchHook2) >> 3];      /* fetchHook code           */
    vernierHook2:
                hex string [(projectHook2 - vernierHook2) >> 3];    /* vernierHook code         */
    projectHook2:
                hex string [(rsvd2Hook2 - projectHook2) >> 3];      /* projectHook code         */
    rsvd2Hook2:
                hex string [(classArray - rsvd2Hook2) >> 3];        /* rsvd2Hook/exitHook code  */                                                  /* code */
    classArray:
                hex string [(typeList - classArray) >> 3];          /* classArray table         */
    typeList:
                hex string [(upperList - typeList) >> 3];           /* typeList table           */
    upperList:
                hex string [(lowerList - upperList) >> 3];          /* upperList table          */
    lowerList:
                hex string [(upperNoMarkList - lowerList) >> 3];    /* lowerList table          */
    upperNoMarkList:
                hex string [(noMarkList - upperNoMarkList) >> 3];   /* upperNoMarkList table    */
    noMarkList:
                hex string [(wordTable - noMarkList) >> 3];         /* noMarkList table         */
    wordTable:
                switch {
                    case tupleFormat:
                        key boolean = 0;
                        hex bitstring[7];                           /* class for null           */
                        hex string [255];                           /* class for other chars    */
                        integer = $$CountOf(WordTuples) - 1;
                        wide array WordTuples {                     /* packed tuple defns       */
                            hex unsigned integer;
                        };
                    case stateFormat:
                        key boolean = 1;
                        bitstring[15];                              /* flags & format           */
                        unsigned hex integer;                       /* version                  */
                        integer = (wordClass - wordTable) >> 3;     /* offset to class table    */
                        integer = (wordAux - wordTable) >> 3;       /* offset to aux class tbl  */
                        integer = (wordBackwd - wordTable) >> 3;    /* offset to back state tbl */
                        integer = (wordForwd - wordTable) >> 3;     /* offset to forw state tbl */
                        integer;                                    /* doBackupMin              */
    wordLength:
                        integer;                                    /* length                   */
    wordClass:
                        hex string [(wordAux - wordClass) >> 3];    /* class table              */
    wordAux:
                        hex string [(wordBackwd - wordAux) >> 3];   /* aux class table          */
    wordBackwd:
                        hex string [(wordForwd - wordBackwd) >> 3]; /* state table for backup   */
    wordForwd:
                        hex string [$$Word(wordLength) - ((wordForwd - wordTable) >> 3)]; /* tbl */
                };
    endWordTable:
                hex string [(wrapTable - endWordTable) >> 3];       /* extra stuff, if any      */
    wrapTable:
                switch {
                    case tupleFormat:
                        key boolean = 0;
                        hex bitstring[7];                           /* class for null           */
                        hex string [255];                           /* class for other chars    */
                        integer = $$CountOf(WrapTuples) - 1;
                        wide array WrapTuples {                     /* packed tuple defns       */
                            hex unsigned integer;
                        };
                    case stateFormat:
                        key boolean = 1;
                        bitstring[15];                              /* flags & format           */
                        unsigned hex integer;                       /* version                  */
                        integer = (wrapClass - wrapTable) >> 3;     /* offset to class table    */
                        integer = (wrapAux - wrapTable) >> 3;       /* offset to aux class tbl  */
                        integer = (wrapBackwd - wrapTable) >> 3;    /* offset to back state tbl */
                        integer = (wrapForwd - wrapTable) >> 3;     /* offset to forw state tbl */
                        integer;                                    /* doBackupMin              */
    wrapLength:
                        integer;                                    /* length                   */
    wrapClass:
                        hex string [(wrapAux - wrapClass) >> 3];    /* class table              */
    wrapAux:
                        hex string [(wrapBackwd - wrapAux) >> 3];   /* aux class table          */
    wrapBackwd:
                        hex string [(wrapForwd - wrapBackwd) >> 3]; /* state table for backup   */
    wrapForwd:
                        hex string [$$Word(wrapLength) - ((wrapForwd - wrapTable) >> 3)]; /* tbl */
                };
    endWrapTable:
                array [$$Word(formatCode) == 0] {
                    hex string;                                     /* extra stuff, if any      */
                };
                array [$$Word(formatCode) == 1] {
                    array [$$Word(findScriptTableOffset) == 0] {
                        hex string;                                 /* extra stuff, if any      */
                    };
                    array [$$Word(findScriptTableOffset) != 0] {
                        hex string [(findScriptTable[1,1] - endWrapTable) >> 3]; /* xtra stuff? */
                    };
                };
                array [$$Word(formatCode) == 1] {
                    array [$$Word(findScriptTableOffset) != 0] {
    findScriptTable:
                        hex string;                                 /* findScriptTable          */
                    };
                };
        };
};
æC

æKY itl4
æFr SysTypes.r
æT
æD /*----------------------------itl4 • International Tokenizer----------------------------*/
type 'itl4' {
        unsigned hex integer;                                       /* flags                    */
        literal longint = 'itl4';                                   /* resource type            */
        integer;                                                    /* resource ID              */
        unsigned hex integer;                                       /* version number           */
    formatCode:
        switch {
            case noLengthFields:
                key integer = 0;                                    /* format code              */
                integer = 0;                                        /* reserved                 */
                longint = 0;                                        /* reserved                 */
                integer = 8;                                        /* # of table entries       */
                unsigned longint = mapCharTable >> 3;               /* MapChar offset           */
                unsigned longint = stringCopyCode >> 3;             /* stringCopy offset        */
                unsigned longint = extendFetchCode >> 3;            /* extendFetch offset       */
                unsigned longint = unTokenTable >> 3;               /* unToken offset           */
                unsigned longint = defaultPartsTable >> 3;          /* defaultParts offset      */
                unsigned longint = whiteSpaceList[1] >> 3;          /* whiteSpaceList offset    */
                unsigned longint = 0;                               /* reserved offset          */
                unsigned longint = 0;                               /* reserved offset          */
            case haveLengthFields:
                key integer = 1;                                    /* format code              */
                integer = 0;                                        /* reserved                 */
                longint = 0;                                        /* reserved                 */
                integer = 8;                                        /* # of table entries       */
                unsigned longint = mapCharTable >> 3;               /* MapChar offset           */
                unsigned longint = stringCopyCode >> 3;             /* stringCopy offset        */
                unsigned longint = extendFetchCode >> 3;            /* extendFetch offset       */
                unsigned longint = unTokenTable >> 3;               /* unToken offset           */
                unsigned longint = defaultPartsTable >> 3;          /* defaultPartsTable offset */
                unsigned longint = whiteSpaceList[1] >> 3;          /* whiteSpaceList offset    */
                unsigned longint = 0;                               /* reserved offset          */
                unsigned longint = 0;                               /* reserved offset          */
                integer;                                            /* MapChar length           */
                integer;                                            /* StringCopy length        */
                integer;                                            /* extendFetch length       */
                integer;                                            /* unToken length           */
                integer;                                            /* defaultPartsTable length */
                integer;                                            /* whiteSpaceList length    */
                integer = 0;                                        /* reserved length          */
                integer = 0;                                        /* reserved length          */
        };


        unsigned longint;                                           /* extendFetch abort offset */
        longint = $$CountOf(MapChar);
    mapCharTable:
        array MapChar {
            byte;
        };

    extendFetchCode:
        hex string [(stringCopyCode - extendFetchCode) >> 3];       /* extendFetch code         */
    stringCopyCode:
        hex string [(unTokenTable - stringCopyCode) >> 3];          /* stringCopy code          */
    unTokenTable:
        integer = (defaultPartsTable - unTokenTable) >> 3;          /* unToken table size       */
    unTokenCount:
        integer = $$CountOf(unTokenStringOffsets) - 1;
        array unTokenStringOffsets {
            integer;                                                /* offset to token strings  */
        };
        array [$$Word(unTokenCount) + 1] {
            pstring;                                                /* token strings            */
            align word;
        };

    defaultPartsTable:
        integer;                                                    /* version number           */
        wide array [31] {
            unsigned byte;
            char;
        };
        integer;                                                    /* size                     */
        wide array [10] {
            unsigned byte;
            char;
        };
        integer;                                                    /* size                     */
        wide array [10] {
            unsigned byte;
            char;
        };
        integer;                                                    /* size                     */
        wide array [10] {
            unsigned byte;
            char;
        };
        integer;                                                    /* size                     */
        wide array [10] {
            unsigned byte;
            char;
        };
        hex string [20] = "";

        array [$$BitField(formatCode,30*8,32) != 0] {
    whiteSpaceList:
            integer = (whiteSpaceListEnd[1] - whiteSpaceList[1]) >> 3; /* whiteSpaceList size   */
    whiteSpaceListCount:
            integer = $$CountOf(whiteSpaceStringOffsets);
            array whiteSpaceStringOffsets {
                integer;                                            /* offset to string         */
            };
            array [$$Word(whiteSpaceListCount[1])] {
                pstring;                                            /* whitespace string        */
                align word;
            };
    whiteSpaceListEnd:
        };
};
æC

æKY itlb
æFr SysTypes.r
æT
æD /*----------------------------itlb • International Script Bundle------------------------*/
type 'itlb' {
        integer;                                                /* itl0 id number       */              /*<6>*/
        integer;                                                /* itl1 id number       */              /*<6>*/
        integer;                                                /* itl2 id number       */              /*<6>*/
        unsigned hex integer;                                   /* script flags - see
                                                                   smScriptFlags info
                                                                   in ScriptEqu.a       */
        integer;                                                /* itl4 id number       */              /*<6>*/
        integer;                                                /* id number of optional itl5, or 0 */  /*<13>*/
        unsigned integer;                                       /* Script language      */
        unsigned integer;                                       /* high byte - number
                                                                   representation code,
                                                                   low byte - date
                                                                   representation code  */
        integer;                                                /* KCHR id number       */              /*<6>*/
        integer;                                                /* id no. of SICN or kcs#,kcs4,kcs8 */  /*<6>*/
        unsigned longint;                                       /* size of script's local record    */  /*<6>*/
        integer;                                                /* default monospace FOND ID        */  /*<6>*/
        unsigned integer;                                       /* default monospace font size      */  /*<6>*/
        integer;                                                /* preferred FOND ID                */  /*<6>*/
        unsigned integer;                                       /* preferred font size              */  /*<6>*/
        integer;                                                /* default small FOND ID            */  /*<6>*/
        unsigned integer;                                       /* default small font size          */  /*<6>*/
        integer;                                                /* default system FOND ID           */  /*<6>*/
        unsigned integer;                                       /* default system font size         */  /*<6>*/
        integer;                                                /* default application FOND ID      */  /*<6>*/
        unsigned integer;                                       /* default application font size    */  /*<6>*/
        integer;                                                /* default Help Mgr FOND ID         */  /*<6>*/
        unsigned integer;                                       /* default Help Mgr font size       */  /*<6>*/
        hex byte;                                               /* valid styles for script              /*<10>*/
        hex byte;                                               /* alias style for script           */  /*<10>*/
};
æC

æKY itlc
æFr SysTypes.r
æT
æD /*----------------------------itlc • International Configuration------------------------*/
type 'itlc' {
        unsigned integer;                                       /* system script code   */
        unsigned integer;                                       /* keyboard cache size  */
        byte            noFontForce, fontForce = 255;           /* font force flag      */
        byte            noIntlForce, intlForce = 255;           /* intl force flag      */
        byte            noOldKeyboard, oldKeyboard = 255;       /* old keyboard         */
        unsigned hex byte;                                      /* general flags - see
                                                                   smGenFlags info in
                                                                   ScriptEqu.a          */
        integer;                                                /* script icon offset   */
        byte                rightOffset, leftOffset = 255;      /* menu side for offset */
        byte;                                                   /* icon data (rsvd)     */
        unsigned integer    Region;                             /* pref. region code    */
        hex string [34];                                        /* reserved             */
};
æC

æKY itlk
æFr SysTypes.r
æT
æD /*----------------------------itlk • Keyboard-dependent Remapping-----------------------*/
type 'itlk' {
        integer = $$CountOf(RemapItemArray);
        wide array RemapItemArray {
            integer;                                            /* keyboard type        */
            hex byte;                                           /* old modifier bits    */
            byte;                                               /* old key code         */
            hex byte;                                           /* modifier bits mask   */
            byte;                                               /* key code mask        */
            hex byte;                                           /* new modifier bits    */
            byte;                                               /* new key code         */
        };
};
æC

æKY itlm
æFr SysTypes.r
æT
æD /*----------------------------itlm • Multiscript mapping/sorting-----------------------*/
type 'itlm' {
        unsigned hex integer;                                   /* version number                   */
        unsigned hex integer;                                   /* format code                      */
        unsigned integer = 3;                                   /* number of offset/length pairs    */
        unsigned longint = scriptData >> 3;                     /* offset to scriptData table       */
        unsigned longint = (endScriptData - scriptData) >> 3;   /* length of scriptData table       */
        unsigned longint = langData >> 3;                       /* offset to langData table         */
        unsigned longint = (endLangData - langData) >> 3;       /* length of langData table         */
        unsigned longint = regionData >> 3;                     /* offset to regionData table       */
        unsigned longint = (endRegionData - regionData) >> 3;   /* length of regionData table       */

scriptData:
        integer Script;                             /* max script code for script->lang mapping     */
        integer Language;                           /* default lang code for scripts not in table   */
        integer = $$CountOf(scriptArray);           /* number of entries in table                   */
        array scriptArray {                         /* entries are ordered by script sort order     */
            integer Script;                         /* script code                                  */
            integer Language;                       /* default language code for script             */
        };
endScriptData:

langData:
        integer Language;                           /* max lang code for lang->script mapping       */
        integer Script;                             /* default script code for langs not in table   */
        integer = $$CountOf(langArray);             /* number of entries in table                   */
        array langArray {                           /* entries are ordered by lang sort order       */
            integer Language;                       /* language code                                */
            integer Script;                         /* code of script to which this lang belongs    */
        };
endLangData:

regionData:
        integer Region;                             /* max region code for region->lang mapping     */
        integer Language;                           /* default lang code for regions not in table   */
        integer = $$CountOf(regionArray);           /* number of entries in table                   */
        array regionArray {                         /* entries are ordered by region sort order     */
            integer Region;                         /* region code                                  */
            integer Language;                       /* parent language code for region              */
        };
endRegionData:
};

æC

æKY 'KCAP'
æFr SysTypes.r
æT
æD /*----------------------------KCAP • Physical Layout of Keyboard------------------------*/
type 'KCAP' {
        rect;                                                   /* boundsRect           */
        rect;                                                   /* textRect             */
        integer = $$CountOf(MainArray);
        array MainArray {
            integer = $$CountOf(ShapeArray) - 1;
            wide array ShapeArray {
                point;                                          /* shapePoint           */
            };
            integer = $$CountOf(KeyArray) - 1;
            wide array KeyArray {
                byte;                                           /* mask                 */
                boolean             or, and;
                bitstring[7];                                   /* keyCode              */
                integer;                                        /* dv                   */
                integer;                                        /* dh                   */
            };
        };
};
æC

æKY KCHR
æFr SysTypes.r
æT
æD /*----------------------------KCHR • ASCII Mapping (software)---------------------------*/
type 'KCHR' {
        integer;                                                /* Version              */
        wide array [$100] {                                     /* Indexes              */
            byte;
        };
        integer = $$CountOf(TableArray);
        array TableArray {
            wide array [$80] {                                  /* ASCII characters     */
                char;
            };
        };
        integer = $$CountOf(DeadArray);
        array DeadArray {
            byte;                                               /* Table number         */
            byte;                                               /* Virtual keycode      */
            integer = $$CountOf(CompletorArray);
            wide array CompletorArray {
                char;                                           /* Completor char       */
                char;                                           /* Substituting char    */
            };
            char;                                               /* No match char        */
            char;                                               /* 16-bits for the times
                                                                   when 8 isn't enough  */
        };
};
æC

æKY KMAP
æFr SysTypes.r
æT
æD /*----------------------------KMAP • Keyboard Mapping (hardware)------------------------*/
type 'KMAP' {
        integer;                                                /* ID                   */
        integer;                                                /* Version              */
        wide array [$80] {                                      /* Raw to virtual       */
            byte;                                               /*  keycode map         */
        };
        integer = $$CountOf(ExceptionArray);
        wide array ExceptionArray {
            byte;                                               /* Raw keycode          */
            boolean         noXor, Xor;
            fill bit[3];
            bitstring[4];                                       /* ADB op               */
            pstring;
        };
};
æC

æKY KSWP
æFr SysTypes.r
æT
æD /*----------------------------KSWP • Keyboard Swapping----------------------------------*/
type 'KSWP' {
        /* The expression below that calculates the number of elements in the
           array is complicated because of the way that $$ResourceSize works.
           $$ResourceSize returns the size of the resource.  When derez'ing a
           resource, the size of the resource is known from the start.  When
           rez'ing a resource, however, the size starts out at zero and is
           incremented each time a field is appended to the resource data.  In
           other words, while rez'ing, $$ResourceSize rarely returns the final
           size of the resource.  When rez'ing a KSWP, the array size expression
           is not evaluated until all of the array elements have been parsed.
           Since each array element is 4 bytes long (if you add up all the fields),
           the number of array elements is the size of the resource at that point
           divided by four.  Since the preprocessor value of "DeRez" is zero when
           Rez'ing, the expression is equivalent to $$ResourceSize / 4.  When
           derez'ing a KSWP, the value of $$ResourceSize is constant: always the
           total size of the resource, in bytes.  Since the resource contains 4
           bytes of fill at the end (which happens to be the size of an array
           element), we have to take that in consideration when calculating the
           size of the array.  Note that the preprocessor value of "DeRez" is one,
           when derez'ing.
        */
        wide array [$$ResourceSize / 4 - DeRez]{
            hex integer     Roman, Japanese, Chinese, Korean,   /* script code or verb  */
                            Arabic, Hebrew, Greek,
                            Rotate = -1, System = -2,
                            Alternate = -3, RotateKybd = -4;    /* <20> */
            unsigned byte;                                      /* virtual key code     */
            /* Modifiers */
            fill bit;                                           /* rControlOn,rControlOff*/
            fill bit;                                           /* rOptionOn,rOptionOff */
            fill bit;                                           /* rShiftOn,rShiftOff   */
            boolean     controlOff, controlOn;
            boolean     optionOff, optionOn;
            fill bit;                                           /* capsLockOn,capsLockOff*/
            boolean     shiftOff, shiftOn;
            boolean     commandOff, commandOn;
        };
        fill long;
};
æC

æKY mach
æFr SysTypes.r
æT
æD /*----------------------------mach • cdev filtering-------------------------------------*/
type 'mach' {
        unsigned hex integer;                                               /* Softmask */
        unsigned hex integer;                                               /* Hardmask */
};
æC

æKY mcky
æFr SysTypes.r
æT
æD /*----------------------------mcky • Mouse Tracking-------------------------------------*/
type 'mcky' {
        array [8] {
            unsigned byte;
        };
};
æC

æKY mppc
æFr SysTypes.r
æT
æD /*----------------------------mppc • MPP Configuration Resource-------------------------*/
type 'mppc' {
        unsigned hex longint;                                   /* Info passed to drvr  */
        byte;                                                   /* Override version #   */
        fill byte;                                              /* Reserved             */
};
æC

æKY NFNT
æFr SysTypes.r
æT
æD /*----------------------------NFNT • Font Description-----------------------------------*/
type 'NFNT' as 'FONT';
æC

æKY nrct
æFr SysTypes.r
æT
æD /*----------------------------nrct • Rectangle List-------------------------------------*/
type 'nrct' {
        integer = $$CountOf(RectArray);                         /* Number of rectangles */
        array RectArray {
            rect;
        };
};

æC

æKY ROv#
æFr SysTypes.r
æT
æD /*----------------------------ROv# • ROM Resource Override------------------------------*/
type 'ROv#' {
        unsigned hex integer;                                   /* Version # of ROM     */
        integer = $$CountOf(typeList) - 1;                      /* Number of resources  */
        wide array typeList {
            literal longint;                                    /* Resource type        */
            integer;                                            /* Resource id          */
        };
};
æC

æKY scrn
æFr SysTypes.r
æT
æD /*----------------------------scrn • Screen Configuration-------------------------------*/
type 'scrn' {
        integer = $$CountOf(Device);                            /* Number of displays   */
        wide array Device {
            unsigned hex integer;                               /* sRsrc Type           */
            integer;                                            /* Slot number          */
            unsigned hex longint;                               /* dCtlDevBase          */
            integer;                                            /* sRsrcID for mode     */
            integer = $77FE;                                    /* Flag mask            */
            Boolean         inactive, active;                   /* Device active flag   */
            fill bit[3];                                        /* reserved             */
            Boolean         auxillaryScreen, mainScreen;        /* Main screen flag     */
            unsigned bitstring[10] = 0;                         /* reserved             */
            Boolean         monochrome, color;                  /* Device type          */
            integer;                                            /* Rsrc ID of 'clut'    */
            integer;                                            /* Rsrc ID of 'gama'    */
            Rect;                                               /* Device's global rect */
            integer = $$CountOf(ControlCalls);                  /* # of control calls   */
            wide array ControlCalls {
                integer;                                        /* csCode for this call */
                wstring;                                        /* param block data     */
                align word;

            };
        };
};
æC

æKY snd
æFr SysTypes.r
æT
æD /*----------------------------snd  • Sound----------------------------------------------*/
/*----------------------------snd  • Sound----------------------------------------------*/
type 'snd ' {
        switch {
            case FormatOne:
                key unsigned integer = $0001;
                unsigned integer = $$CountOf(Synthesizers);
                wide array Synthesizers {
                    /* Resource ID of synthesizer/modifer */
                    integer     squareWaveSynth     = $0001,
                                waveTableSynth      = $0003,
                                sampledSynth        = $0005;
                    longint;                                    /* init parameter       */
                };

            case FormatTwo:
                key unsigned integer = $0002;
                integer     free = 0, keepInMemory = 256+1;     /* Space for refe count */
        };
        unsigned integer = $$CountOf(SoundCmnds);
        wide array SoundCmnds {
            boolean     noData, hasData;
            switch {
                case nullCmd:
                    key bitstring[15] = 0;
                    fill word;                                  /* Param 1 = nil        */
                    fill long;                                  /* Param 2 = nil        */
                case quietCmd:
                    key bitstring[15] = 3;
                    fill word;                                  /* Param 1 = nil        */
                    fill long;                                  /* Param 2 = nil        */
                case flushCmd:
                    key bitstring[15] = 4;
                    fill word;                                  /* Param 1 = nil        */
                    fill long;                                  /* Param 2 = nil        */
                case waitCmd:
                    key bitstring[15] = 10;
                    integer     oneSecond = 2000;               /* Duration             */
                    fill long;                                  /* Param 2 = nil        */
                case pauseCmd:
                    key bitstring[15] = 11;
                    fill word;                                  /* Param 1 = nil        */
                    fill long;                                  /* Param 2 = nil        */
                case resumeCmd:
                    key bitstring[15] = 12;
                    fill word;                                  /* Param 1 = nil        */
                    fill long;                                  /* Param 2 = nil        */
                case callBackCmd:
                    key bitstring[15] = 13;
                    integer;                                    /* User-defined         */
                    longint;                                    /* User-defined         */
                case syncCmd:
                    key bitstring[15] = 14;
                    integer;                                    /* Count                */
                    longint;                                    /* Identifier           */
                case emptyCmd:
                    key bitstring[15] = 15;
                    fill word;                                  /* Param 1 = nil        */
                    fill long;                                  /* Param 2 = nil        */
                case freqDurationCmd:
                    key bitstring[15] = 40;
                    integer     oneSecond = 2000;               /* Duration             */
                    longint;                                    /* frequency            */
                case restCmd:
                    key bitstring[15] = 41;
                    integer     oneSecond = 2000;               /* Duration             */
                    fill long;                                  /* Param 2 = nil        */
                case freqCmd:
                    key bitstring[15] = 42;
                    fill word;                                  /* Param 1 = nil        */
                    longint;                                    /* Frequency            */
                case ampCmd:
                    key bitstring[15] = 43;
                    integer;                                    /* Amplitude            */
                    fill long;                                  /* Param 2              */
                case timbreCmd:
                    key bitstring[15] = 44;
                    integer     sineWave, squareWave = 255;     /* Timbre               */
                    fill long;                                  /* Param 2              */
                case waveTableCmd:
                    key bitstring[15] = 60;
                    unsigned integer;                           /* Length               */
                    longint;                                    /* Pointer to table     */
                case phaseCmd:
                    key bitstring[15] = 61;
                    integer;                                    /* Shift                */
                    longint;                                    /* chanPtr              */
                case soundCmd:
                    key bitstring[15] = 80;
                    fill word;                                  /* Param 1 = nil        */
                    longint;                                    /* Pointer to sound     */
                case bufferCmd:
                    key bitstring[15] = 81;
                    fill word;                                  /* Param 1 = nil        */
                    longint;                                    /* Pointer to buffer    */
                case rateCmd:
                    key bitstring[15] = 82;
                    fill word;                                  /* Param 1 = nil        */
                    longint;                                    /* Rate                 */
            };
        };
        array DataTables {
    DataTable:
            fill long;                                          /* Pointer to data      */
    SampleCnt:
            unsigned longint;                                   /* # of sound samples   */
            unsigned hex longint
                    Rate22K = $56EE8BA3;                        /* Sampling rate        */
            unsigned longint;                                   /* Start of loop        */
            unsigned longint;                                   /* End of loop          */
            hex byte;                                           /* encode (header type) */
            hex byte;                                           /* baseFrequency        */
            hex string [$$Long(SampleCnt[$$ArrayIndex(DataTables)])];
        };
};
æC

æKY vers
æFr SysTypes.r
æT
æD /*----------------------------vers • Version--------------------------------------------*/
type 'vers' {
        hex byte;                                               /* Major revision in BCD*/
        hex byte;                                               /* Minor vevision in BCD*/
        hex byte    development = 0x20,                         /* Release stage        */
                    alpha = 0x40,
                    beta = 0x60,
                    final = 0x80, /* or */ release = 0x80;
        hex byte;                                               /* Non-final release #  */
        integer     Region;                                     /* Region code          */
        pstring;                                                /* Short version number */
        pstring;                                                /* Long version number  */
};
æC

æKY FRSV
æFr SysTypes.r
æT
æD /*--------------------------------------------------------------------------------------*/

/* FRSV and resf • reserved fonts */

    type 'FRSV' {
        integer = $$CountOf(ReservedFontArray);
        wide array ReservedFontArray {
            unsigned bitstring[9]   Chicago = 0, Geneva = 3, Monaco = 4;    // font family
            unsigned bitstring[7];                                          // font size
        };
    };

æC

æKY resf
æFr SysTypes.r
æT
æD     type 'resf' {
        integer = $$CountOf(FamilyArray);
        array FamilyArray {
            pstring;
            align word;
            integer = $$CountOf(FontRecord);
            array FontRecord {
                integer;                        // point size
                integer plain;                  // style
            };
        };
    };

æC

æKY fld#
æFr SysTypes.r
æT
æD /* fld# • list of folder names for Folder Mgr */

    type 'fld#' {
        array {
            literal     longint;                // folder type
            integer     inSystemFolder = 0;     // version
            fill byte;                          // high byte of data length
            pstring;                            // folder name
            align word;
        };
    };

æC

æKY mitq
æFr SysTypes.r
æT
æD /* mitq • default queue sizes for MakeITable */

    type 'mitq' {               // default MakeITable queue sizes
        wide array [3] {
            unsigned longint;   // queue size for 3, 4, and 5 bit inverse tables
        };
    };

æC

æKY  ppcc
æFr SysTypes.r
æT
æD /* ppcc • PPC Browser Configuration Resource */

    type 'ppcc' {
        unsigned byte;  // NBP lookup interval
        unsigned byte;  // NBP lookup count
        integer;        // NBP maximum lives an entry has before deletion
        integer;        // NBP maximum number of entities
        integer;        // NBP idle time in ticks between lookups
        integer;        // PPC maximum number of ports
        integer;        // PPC idle time in ticks between list ports
    };

/*--------------------------------------------------------------------------------------*/

#endif __SYSTYPES.R__



æKY Types.r
æKL
acceptAppDiedEvents
actb
acur
aedt
ALRT
beepStage
beepStages
BitMapRowBytes
blackRGB
BNDLtype
boldType
cctb
cicn
clut
CNTL
condenseType
crsr
CURS
dctb
dflg
disableOptionSwitch
DITLtype
DLOG
doesActivateOnFGSwitch
dontSaveScreen
enableOptionSwitch
eppc
extendType
fctb
FREFtype
icl4
icl8
icm#
icm4
icm8
ICN#type
ICON
ics#
ics4
ics8
ignoreAppDiedEvents
invertRGB
italicType
MBARtype
mctb
MENU
needsActivateOnFGSwitch
outlineType
PAT
PAT#
PICTtype
PixMapBounds
PixMapHeight
PixMapHeightIndexed
PixMapRowBytes
PixMapRowBytesIndexed
PixMapWidth
PixMapWidthIndexed
pltt
popupFixedWidth
popupMenuCDEFproc
popupReserved
popupTitleBold
popupTitleCenterJust
popupTitleCondense
popupTitleExtend
popupTitleItalic
popupTitleLeftJust
popupTitleNoStyle
popupTitleOutline
popupTitleRightJust
popupTitleShadow
popupTitleUnderline
popupUseAddResMenu
popupUseWFont
ppat
ppt#
qrsc
RECT
saveScreen
shadowType
SICN
silentStage
silentStages
SIZEtype
STR
STR#
SystemSevenOrLater
transparentRGB
underlineType
wctb
whiteRGB
WIND
wstr

æKY SystemSevenOrLater
æFr Types.r
æT #define
æD #ifndef SystemSevenOrLater
#define SystemSevenOrLater 0
#endif

æC

æKY PixMapHeight
æFr Types.r
æT #define
æD #define PixMapHeight    ( $$BitField(Bounds, 32, 16) /* bottom */           \
                        - $$BitField(Bounds, 0, 16) /* top */ )
æC

æKY PixMapWidth
æFr Types.r
æT #define
æD #define PixMapWidth     ( $$BitField(Bounds, 48, 16) /* right */            \
                        - $$BitField(Bounds, 16, 16) /* left */ )
æC

æKY PixMapBounds
æFr Types.r
æT #define
æD #define PixMapBounds    integer = $$BitField(Bounds, 0, 16) /* top */;      \
                        integer = $$BitField(Bounds, 16, 16) /* left */;    \
                        integer = $$BitField(Bounds, 32, 16) /* bottom */;  \
                        integer = $$BitField(Bounds, 48, 16) /* right */
æC

æKY PixMapRowBytes
æFr Types.r
æT #define
æD #define PixMapRowBytes  (((PixMapWidth * $$Word(PixelSize) + 15) / 16) * 2)
æC

æKY BitMapRowBytes
æFr Types.r
æT #define
æD #define BitMapRowBytes  (((PixMapWidth + 15) / 16) * 2)

æC

æKY PixMapHeightIndexed
æFr Types.r
æT #define
æD #define PixMapHeightIndexed     ( $$BitField(Bounds[$$ArrayIndex(PixPatArray)], 32, 16) /* bottom */            \
                                - $$BitField(Bounds[$$ArrayIndex(PixPatArray)], 0, 16) /* top */ )
æC

æKY PixMapWidthIndexed
æFr Types.r
æT #define
æD #define PixMapWidthIndexed      ( $$BitField(Bounds[$$ArrayIndex(PixPatArray)], 48, 16) /* right */         \
                                - $$BitField(Bounds[$$ArrayIndex(PixPatArray)], 16, 16) /* left */ )
æC

æKY PixMapRowBytesIndexed
æFr Types.r
æT #define
æD #define PixMapRowBytesIndexed   (((PixMapWidthIndexed * $$Word(PixelSize[$$ArrayIndex(PixPatArray)]) + 15) / 16) * 2)

æC

æKY boldType
æFr Types.r
æT #define
æD #define bold             1
æC

æKY italicType
æFr Types.r
æT #define
æD #define italic           2
æC

æKY underlineType
æFr Types.r
æT #define
æD #define underline        4
æC

æKY outlineType
æFr Types.r
æT #define
æD #define outline          8
æC

æKY shadowType
æFr Types.r
æT #define
æD #define shadow          16
æC

æKY condenseType
æFr Types.r
æT #define
æD #define condense        32
æC

æKY extendType
æFr Types.r
æT #define
æD #define extend          64
æC

æKY acur
æFr Types.r
æT
æD
/*----------------------------acur • Cursor Pointers -----------------------------------*/
type 'acur' {
       integer = $$CountOf(CursIdArray); /* Nbr of cursors                 */
       fill word;                        /* Next frame to show             */
       array CursIdArray {
           integer;                      /* 'CURS' resource id for a frame */
           fill word;                    /* Pad word to make longint       */
       };
};
æC

æKY actb
æFr Types.r
æT
æD #Ifdef oldTemp
/*--------------------------actb • Alert Color old Lookup Table--------------------------*/
    type 'actb' {
            unsigned hex longint;                                   /* ctSeed               */
            integer;                                                /* ctFlags              */
            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
            wide array ColorSpec {
                    integer     wContentColor,                      /* value                */
                                wFrameColor,
                                wTextColor,
                                wHiliteColor,
                                wTitleBarColor;
                    unsigned integer;                               /* RGB: red             */
                    unsigned integer;                               /*      green           */
                    unsigned integer;                               /*      blue            */
            };
    };
#else
/*----------------------------actb • Alert Color Lookup Table----------------------------*/
    type 'actb' {
            unsigned hex longint = 0;                               /* ctSeed               */
            integer = 0;                                            /* ctFlags              */
            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
            wide array ColorSpec {
                    integer     wContentColor,                      /* value                */
                                wFrameColor,
                                wTextColor,
                                wHiliteColor,
                            wTitleBarColor,
                            wHiliteLight,
                            wHiliteDark,
                            wTitleBarLight,
                            wTitleBarDark,
                            wDialogLight,
                            wDialogDark,
                            wTingeLight,
                            wTingeDark;
                    unsigned integer;                               /* RGB: red             */
                    unsigned integer;                               /*      green           */
                    unsigned integer;                               /*      blue            */
            };
    };
#endif
æC

æKY aedt
æFr Types.r
æT
æD /*--------------------------aedt • Apple Events Template---------------------------------*/
/* Resource definition used for associating a value with an apple event */
/* This really only useful for general dispatching */

type 'aedt' {
    wide array {
    unsigned longint;   /* Event Class  */
    unsigned longint;   /* Event ID     */
    unsigned longint;   /* Value    */
    };
};
æC

æKY ALRT
æFr Types.r
æT
æD /*----------------------------ALRT • Alert Template-------------------------------------*/
type 'ALRT' {
        rect;                                                   /* boundsRect           */
        integer;                                                /* 'DITL' ID            */

        /* NOTE: the stages are ordered 4, 3, 2, 1 */
        wide array [4] {
                boolean                 OK, Cancel;             /* Bold Outline         */
                boolean                 invisible, visible;     /* Draw Alert           */
                unsigned bitstring[2]   silent = 0
                                sound1, sound2, sound3;         /* Beeps                */
        };

    /*  The following are window positioning options ,usable in 7.0 */
#if SystemSevenOrLater
        unsigned integer                noAutoCenter = 0x0000,
                                        centerMainScreen = 0x280a,
                                        alertPositionMainScreen = 0x300a,
                                        staggerMainScreen = 0x380a,
                                        centerParentWindow = 0xa80a,
                                        alertPositionParentWindow = 0xb00a,
                                        staggerParentWindow = 0xb80a,
                                        centerParentWindowScreen = 0x680a,
                                        alertPositionParentWindowScreen = 0x700a,
                                        staggerParentWindowScreen = 0x780a;
#endif
};
æC

æKY BNDLtype
æFr Types.r
æT
æD /*----------------------------BNDL • Bundle---------------------------------------------*/
type 'BNDL' {
        literal longint;                                        /* Signature            */
        integer;                                                /* Version ID           */
        integer = $$CountOf(TypeArray) - 1;
        array TypeArray {
                literal longint;                                /* Type                 */
                integer = $$CountOf(IDArray) - 1;
                wide array IDArray {
                        integer;                                /* Local ID             */
                        integer;                                /* Actual ID            */
                };
        };
};
æC

æKY cctb
æFr Types.r
æT
æD #Ifdef oldTemp
/*--------------------------cctb • Control Color old Lookup Table----------------------*/
    type 'cctb' {
            unsigned hex longint;                                   /* CCSeed               */
            integer;                                                /* ccReserved           */
            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
            wide array ColorSpec {
                    integer     cFrameColor,                        /* partcode             */
                                cBodyColor,
                                cTextColor,
                                cElevatorColor;
                    unsigned integer;                               /* RGB: red             */
                    unsigned integer;                               /*      green           */
                    unsigned integer;                               /*      blue            */
            };
    };
#else
/*----------------------------cctb • Control Color Lookup Table-------------------------*/
type 'cctb' {
        unsigned hex longint = 0;                               /* CCSeed               */
        integer = 0;                                            /* ccReserved           */
        integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
        wide array ColorSpec {
                integer     cFrameColor,                        /* partcode             */
                            cBodyColor,
                            cTextColor,
                            cElevatorColor,
                            cFillPatColor,
                            cArrowsLight,
                            cArrowsDark,
                            cThumbLight,
                            cThumbDark,
                            cHiliteLight,
                            cHiliteDark,
                            cTitleBarLight,
                            cTitleBarDark,
                            cTingeLight,
                            cTingeDark;
                unsigned integer;                               /* RGB: red             */
                unsigned integer;                               /*      green           */
                unsigned integer;                               /*      blue            */
        };
};
#endif
æC

æKY cicn
æFr Types.r
æT
æD #ifdef oldTemp
/*-----------------------cicn • Color Icon old template-------------------------------------*/
    type 'cicn' {
            /* IconPMap (pixMap) record */
            fill long;                                              /* Base address         */
            unsigned bitstring[1] = 1;                              /* New pixMap flag      */
            unsigned bitstring[2] = 0;                              /* Must be 0            */
    pMapRowBytes:
            unsigned bitstring[13];                                 /* Offset to next row   */
    Bounds:
            rect;                                                   /* Bitmap bounds        */
            integer;                                                /* pixMap vers number   */
            integer unpacked;                                       /* Packing format       */
            unsigned longint;                                       /* Size of pixel data   */
            unsigned hex longint;                                   /* h. resolution (ppi) (fixed) */
            unsigned hex longint;                                   /* v. resolution (ppi) (fixed) */
            integer         chunky, chunkyPlanar, planar;           /* Pixel storage format */
            integer;                                                /* # bits in pixel      */
            integer;                                                /* # components in pixel*/
            integer;                                                /* # bits per field     */
            unsigned longint;                                       /* Offset to next plane */
            unsigned longint;                                       /* Offset to color table*/
            fill long;                                              /* Reserved             */

            /* IconMask (bitMap) record */
            fill long;                                              /* Base address         */
    maskRowBytes:
            integer;                                                /* Row bytes            */
            rect;                                                   /* Bitmap bounds        */

            /* IconBMap (bitMap) record */
            fill long;                                              /* Base address         */
    iconBMapRowBytes:
            integer;                                                /* Row bytes            */
            rect;                                                   /* Bitmap bounds        */

            fill long;                                              /* Handle placeholder   */

            /* Mask data */
            hex string [$$Word(maskRowBytes) * PIXMAPHEIGHT];

            /* BitMap data */
            hex string [$$Word(iconBMapRowBytes) * PIXMAPHEIGHT];

            /* Color Table */
            unsigned hex longint;                                   /* ctSeed               */
            integer;                                                /* ctFlags              */
            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
            wide array ColorSpec {
                    integer;                                        /* value                */
                    unsigned integer;                               /* RGB: red             */
                    unsigned integer;                               /*      green           */
                    unsigned integer;                               /*      blue            */
            };

            /* PixelMap data */
            hex string [$$BitField(pMapRowBytes, 0, 13) * PIXMAPHEIGHT];
    };
#else
/*----------------------------cicn • Color Icon-----------------------------------------*/
    type 'cicn' {
            /* IconPMap (pixMap) record */
            fill long;                                              /* Base address         */
            unsigned bitstring[1] = 1;                              /* New pixMap flag      */
            unsigned bitstring[2] = 0;                              /* Must be 0            */
    pMapRowBytes:
            unsigned bitstring[13];                                 /* Offset to next row   */
    Bounds: rect;                                                   /* Bitmap bounds        */
            integer = 0;                                            /* pixMap vers number   */
            integer = 0;                                            /* Packing format       */
            fill long;                                              /* Size of pixel data   */
            unsigned hex longint = $00480000;                       /* h. resolution (ppi)  */
            unsigned hex longint = $00480000;                       /* v. resolution (ppi)  */
            integer = 0 /* chunky */;                               /* Pixel storage format */
    PixelSize:
            integer;                                                /* # bits in pixel      */
            integer = 1;                                            /* # components in pixel*/
            integer = $$Word(PixelSize);                            /* # bits per field     */
            fill long;
            fill long;
            fill long;

            /* IconMask (bitMap) record */
            fill long;                                              /* Base address         */
            integer = BitMapRowBytes;                               /* Row bytes            */
            PixMapBounds;                                           /* Bitmap bounds        */

            /* IconBMap (bitMap) record */
            fill long;                                              /* Base address         */
            integer = BitMapRowBytes;                               /* Row bytes            */
            PixMapBounds;                                           /* Bitmap bounds        */

            fill long;                                              /* Handle placeholder   */

            /* Mask data */
            hex string [BitMapRowBytes * PixMapHeight];

            /* BitMap data */
            hex string [BitMapRowBytes * PixMapHeight];

    ColorTable:
            unsigned hex longint = 0;                               /* ctSeed               */
            integer = 0;                                            /* ctFlags              */
            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
            wide array ColorSpec {
                    integer;                                        /* value                */
                    unsigned integer;                               /* RGB: red             */
                    unsigned integer;                               /*      green           */
                    unsigned integer;                               /*      blue            */
            };

    PixelData:
            hex string [PixMapRowBytes * PixMapHeight];             /* more of the pixmap   */
    };
#endif
æC

æKY clut
æFr Types.r
æT
æD #Ifdef oldTemp
/*-------------------------- old clut • Generic Color Lookup Table----------------------*/
    type 'clut' {
            unsigned hex longint;                                   /* ctSeed               */
            integer;                                                /* ctFlags              */
            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
            wide array ColorSpec {
                    integer;                                        /* value                */
                    unsigned integer;                               /* RGB: red             */
                    unsigned integer;                               /*      green           */
                    unsigned integer;                               /*      blue            */
            };
    };
#else
/*----------------------------clut • Generic Color Lookup Table-------------------------*/
    type 'clut' {
            unsigned hex longint = 0;                               /* ctSeed               */
            integer = 0;                                            /* ctFlags              */
            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
            wide array ColorSpec {
                    integer = $$ArrayIndex(ColorSpec) - 1;          /* value                */
                    unsigned integer;                               /* RGB: red             */
                    unsigned integer;                               /*      green           */
                    unsigned integer;                               /*      blue            */
            };
    };
#endif
æC

æKY CNTL
æFr Types.r
æT
æD /*----------------------------CNTL • Control Template-----------------------------------*/
type 'CNTL' {
        rect;                                                   /* Bounds               */
        integer;                                                /* Value                */
        byte            invisible, visible;                     /* visible              */
        fill byte;
        integer;                                                /* Max                  */
        integer;                                                /* Min                  */
        integer         pushButProc,                            /* ProcID               */
                        checkBoxProc,
                        radioButProc,
                        pushButProcUseWFont = 8,
                        checkBoxProcUseWFont,
                        radioButProcUseWFont,
                        scrollBarProc = 16;
        longint;                                                /* RefCon               */
        pstring;                                                /* Title                */
};
æC

æKY popupMenuCDEFproc
æFr Types.r
æT #define
æD #define popupMenuCDEFproc          1008
æC

æKY popupFixedWidth
æFr Types.r
æT #define
æD #define popupFixedWidth          0x0001
æC

æKY popupReserved
æFr Types.r
æT #define
æD #define popupReserved            0x0002
æC

æKY popupUseAddResMenu
æFr Types.r
æT #define
æD #define popupUseAddResMenu       0x0004
æC

æKY popupUseWFont
æFr Types.r
æT #define
æD #define popupUseWFont            0x0008
æC

æKY popupTitleBold
æFr Types.r
æT #define
æD #define popupTitleBold           0x0100
æC

æKY popupTitleItalic
æFr Types.r
æT #define
æD #define popupTitleItalic         0x0200
æC

æKY popupTitleUnderline
æFr Types.r
æT #define
æD #define popupTitleUnderline      0x0400
æC

æKY popupTitleOutline
æFr Types.r
æT #define
æD #define popupTitleOutline        0x0800
æC

æKY popupTitleShadow
æFr Types.r
æT #define
æD #define popupTitleShadow         0x1000
æC

æKY popupTitleCondense
æFr Types.r
æT #define
æD #define popupTitleCondense       0x2000
æC

æKY popupTitleExtend
æFr Types.r
æT #define
æD #define popupTitleExtend         0x4000
æC

æKY popupTitleNoStyle
æFr Types.r
æT #define
æD #define popupTitleNoStyle        0x8000
æC

æKY popupTitleLeftJust
æFr Types.r
æT #define
æD #define popupTitleLeftJust       0x0000
æC

æKY popupTitleCenterJust
æFr Types.r
æT #define
æD #define popupTitleCenterJust     0x0001
æC

æKY popupTitleRightJust
æFr Types.r
æT #define
æD #define popupTitleRightJust      0x00FF
æC

æKY crsr
æFr Types.r
æT
æD
#ifdef oldTemp
/*------------------------crsr • old Color Cursor template----------------------------------*/
    type 'crsr' {
            /* CCrsr record */
            hex unsigned integer    oldCursor   = $8000,            /* Type of cursor       */
                                    colorCursor = $8001;
            unsigned longint = pixMap / 8;                          /* Offset to pixMap     */
            unsigned longint = pixelData / 8;                       /* Offset to pixel data */
            fill long;                                              /* Expanded cursor data */
            fill word;                                              /* Expanded data depth  */
            fill long;                                              /* Reserved             */
            hex string [32];                                        /* One bit cursor data  */
            hex string [32];                                        /* One bit cursor mask  */
            point;                                                  /* Hot spot             */
            fill long;                                              /* Table id             */
            fill long;                                              /* id for cursor        */

            /* IconPMap (pixMap) record */
    pixMap:
            fill long;                                              /* Base address         */
            unsigned bitstring[1] = 1;                              /* New pixMap flag      */
            unsigned bitstring[2] = 0;                              /* Must be 0            */
            unsigned bitstring[13];                                 /* Offset to next row   */
            rect;                                                   /* Bitmap bounds        */
            integer;                                                /* pixMap version number*/
            integer unpacked;                                       /* Packing format       */
            unsigned longint;                                       /* Size of pixel data   */
            unsigned hex longint;                                   /* h. resolution (ppi) (fixed) */
            unsigned hex longint;                                   /* v. resolution (ppi) (fixed) */
            integer         chunky, chunkyPlanar, planar;           /* Pixel storage format */
            integer;                                                /* # bits in pixel      */
            integer;                                                /* # components in pixel*/
            integer;                                                /* # bits per field     */
            unsigned longint;                                       /* Offset to next plane */
            unsigned longint = colorTable / 8;                      /* Offset to color table*/
            fill long;                                              /* Reserved             */

    pixelData:
            hex string [(colorTable - pixelData) / 8];              /* Pixel data           */

            /* Color Table */
    colorTable:
            unsigned hex longint;                                   /* ctSeed               */
            integer;                                                /* ctFlags              */
            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
            wide array ColorSpec {
                    integer;                                        /* value                */
                    unsigned integer;                               /* RGB: red             */
                    unsigned integer;                               /*      green           */
                    unsigned integer;                               /*      blue            */
            };
    };
#else
/*----------------------------crsr • Color Cursor---------------------------------------*/
type 'crsr' {
        /* CCrsr record */
        unsigned hex integer = $8001;                           /* Type of cursor       */
        unsigned longint = PixMap / 8;                          /* Offset to pixMap     */
        unsigned longint = PixelData / 8;                       /* Offset to pixel data */
        fill long;                                              /* Expanded cursor data */
        fill word;                                              /* Expanded data depth  */
        fill long;                                              /* Reserved             */
        hex string [32];                                        /* One bit cursor data  */
        hex string [32];                                        /* One bit cursor mask  */
        point;                                                  /* Hot spot             */
        fill long;                                              /* Table id             */
        fill long;                                              /* id for cursor        */

        /* PixMap record */
PixMap:
        fill long;                                              /* Base address         */
        unsigned bitstring[1] = 1;                              /* New pixMap flag      */
        unsigned bitstring[2] = 0;                              /* Must be 0            */
pMapRowBytes:
        unsigned bitstring[13];                                 /* Offset to next row   */

Bounds: rect = { 0, 0, 16, 16 };                                /* Bitmap bounds        */
        integer = 0;                                            /* pixMap vers number   */
        integer = 0;                                            /* Packing format       */
        fill long;                                              /* Size of pixel data   */
        unsigned hex longint = $00480000;                       /* h. resolution (ppi)  */
        unsigned hex longint = $00480000;                       /* v. resolution (ppi)  */
        integer = 0 /* chunky */;                               /* Pixel storage format */
PixelSize:
        integer;                                                /* # bits in pixel      */
        integer = 1;                                            /* # components in pixel*/
        integer = $$Word(PixelSize);                            /* # bits per field     */
        fill long;
        unsigned longint = ColorTable / 8;
        fill long;

PixelData:
        hex string [PixMapRowBytes * PixMapHeight];

ColorTable:
        unsigned hex longint = 0;                               /* ctSeed               */
        integer = 0;                                            /* ctFlags              */
        integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
        wide array ColorSpec {
                integer;                                        /* value                */
                unsigned integer;                               /* RGB: red             */
                unsigned integer;                               /*      green           */
                unsigned integer;                               /*      blue            */
        };
};
#endif
æC

æKY CURS
æFr Types.r
æT
æD /*----------------------------CURS • Cursor---------------------------------------------*/
type 'CURS' {
        hex string [32];                                        /* Data                 */
        hex string [32];                                        /* Mask                 */
        point;                                                  /* Hot spot             */
};
æC

æKY dctb
æFr Types.r
æT
æD /*----------------------------dctb • Dialog Color Lookup Table--------------------------*/
type 'dctb' as 'actb';
æC

æKY DITLtype
æFr Types.r
æT
æD /*----------------------------DITL • Dialog Item List-----------------------------------*/
type 'DITL' {
        integer = $$CountOf(DITLarray) - 1;                     /* Array size           */
        wide array DITLarray {
                fill long;
                rect;                                           /* Item bounds          */
                switch {

                case HelpItem:                                  /* Help Mgr type item */
                        boolean         enabled,disabled;       /* Enable flag          */
                        key bitstring[7] = 1;                   /* this is a new type = 1 */

                        switch {
                            case HMScanhdlg:
                                byte = 4;                       /* sizeola              */
                                key int = 1;                    /* key value            */
                                integer;                        /* resource ID          */

                            case HMScanhrct:
                                byte = 4;                       /* sizeola              */
                                key int = 2;                    /* key value            */
                                integer;                        /* resource ID          */

                            case HMScanAppendhdlg:
                                byte = 6;                       /* sizeola              */
                                key int = 8;                    /* key value            */
                                integer;                        /* resource ID          */
                                integer;                        /* offset (zero based)  */
                        };
                case Button:
                        boolean         enabled,disabled;       /* Enable flag          */
                        key bitstring[7] = 4;
                        pstring;                                /* Title                */

                case CheckBox:
                        boolean         enabled,disabled;       /* Enable flag          */
                        key bitstring[7] = 5;
                        pstring;                                /* Title                */

                case RadioButton:
                        boolean         enabled,disabled;       /* Enable flag          */
                        key bitstring[7] = 6;
                        pstring;                                /* Title                */

                case Control:
                        boolean         enabled,disabled;       /* Enable flag          */
                        key bitstring[7] = 7;
                        byte = 2;
                        integer;                                /* 'CTRL' ID            */

                case StaticText:
                        boolean         enabled,disabled;       /* Enable flag          */
                        key bitstring[7] = 8;
                        pstring;                                /* Text                 */

                case EditText:
                        boolean         enabled,disabled;       /* Enable flag          */
                        key bitstring[7] = 16;
                        pstring;                                /* Text                 */

                case Icon:
                        boolean         enabled,disabled;       /* Enable flag          */
                        key bitstring[7] = 32;
                        byte = 2;
                        integer;                                /* 'ICON' ID            */

                case Picture:
                        boolean         enabled,disabled;       /* Enable flag          */
                        key bitstring[7] = 64;
                        byte = 2;
                        integer;                                /* 'PICT' ID            */

                case UserItem:
                        boolean         enabled,disabled;       /* Enable flag          */
                        key bitstring[7] = 0;
                        byte = 0;
                };
                align word;
        };
};
æC

æKY DLOG
æFr Types.r
æT
æD /*----------------------------DLOG • Dialog Template------------------------------------*/
type 'DLOG' {
        rect;                                                   /* boundsRect           */
        integer         documentProc,                           /* procID               */
                        dBoxProc,
                        plainDBox,
                        altDBoxProc,
                        noGrowDocProc,
                        movableDBoxProc,
                        zoomDocProc = 8,
                        zoomNoGrow = 12,
                        rDocProc = 16;
        byte            invisible, visible;                     /* visible              */
        fill byte;
        byte            noGoAway, goAway;                       /* goAway               */
        fill byte;
        unsigned hex longint;                                   /* refCon               */
        integer;                                                /* 'DITL' ID            */
        pstring;                                                /* title                */
    /*  The following are window positioning options ,usable in 7.0 */
#if SystemSevenOrLater
        align word;
        unsigned integer                noAutoCenter = 0x0000,
                                        centerMainScreen = 0x280a,
                                        alertPositionMainScreen = 0x300a,
                                        staggerMainScreen = 0x380a,
                                        centerParentWindow = 0xa80a,
                                        alertPositionParentWindow = 0xb00a,
                                        staggerParentWindow = 0xb80a,
                                        centerParentWindowScreen = 0x680a,
                                        alertPositionParentWindowScreen = 0x700a,
                                        staggerParentWindowScreen = 0x780a;
#endif
};
æC

æKY eppc
æFr Types.r
æT
æD /*----------------------------------------eppc -----------------------------------------*/
type 'eppc' {
    unsigned longint;   /* flags word   */
    unsigned longint;   /* reserved     */
    unsigned integer;   /* scriptCode   */
    pstring[32];
};
æC

æKY fctb
æFr Types.r
æT
æD /*----------------------------fctb • Font Color Lookup Table----------------------------*/
type 'fctb' as 'clut';
æC

æKY FREFtype
æFr Types.r
æT
æD /*----------------------------FREF • File Reference-------------------------------------*/
type 'FREF' {
        literal longint;                                        /* File Type            */
        integer;                                                /* Icon ID              */
        pstring;                                                /* Filename             */
};
æC

æKY ICON
æFr Types.r
æT
æD /*----------------------------ICON • Icon-----------------------------------------------*/
type 'ICON' {
        hex string[128];                                        /* Icon data            */
};
æC

æKY ICN#type
æFr Types.r
æT
æD /*----------------------------ICN# • Icon List------------------------------------------*/
type 'ICN#' {
        array {
                hex string[128];                                /* Icon data            */
        };
};
type 'KCN#' as 'ICN#';                                          /* Keyboard Icon data <8>*/
æC

æKY MENU
æFr Types.r
æT
æD /*----------------------------MENU • Menu-----------------------------------------------*/
type 'MENU' {
        integer;                                                /* Menu ID              */
        fill word[2];
        integer         textMenuProc = 0;                       /* ID of menu def proc  */
        fill word;
        unsigned hex bitstring[31]
                        allEnabled = 0x7FFFFFFF;                /* Enable flags         */
        boolean         disabled, enabled;                      /* Menu enable          */
        pstring         apple = "\0x14";                        /* Menu Title           */
        wide array {
                pstring;                                        /* Item title           */
                byte            noIcon;                         /* Icon number          */
                char            noKey = "\0x00",                /* Key equivalent or    */
                                hierarchicalMenu = "\0x1B";     /* hierarchical menu    */
                char            noMark = "\0x00",               /* Marking char or id   */
                                check = "\0x12";                /* of hierarchical menu */
                fill bit;
                unsigned bitstring[7]
                                plain;                          /* Style                */
        };
        byte = 0;
};
æC

æKY MBARtype
æFr Types.r
æT
æD /*----------------------------MBAR • Menu Bar-------------------------------------------*/
type 'MBAR' {
        integer = $$CountOf(MenuArray);                         /* Number of menus      */
        wide array MenuArray{
                integer;                                        /* Menu resource ID     */
        };
};
æC

æKY mctb
æFr Types.r
æT
æD /*----------------------------mctb • Menu Color Lookup Table----------------------------*/
type 'mctb' {
        integer = $$CountOf(MCTBArray);                         /* Color table count    */
        wide array MCTBArray {
            integer             mctbLast = -99;                 /* Menu resource ID     */
            integer;                                            /* Menu Item            */
            wide array [4] {
                    unsigned integer;                           /* RGB: red             */
                    unsigned integer;                           /*      green           */
                    unsigned integer;                           /*      blue            */
            };
            fill word;                                          /* Reserved word        */
        };
};
æC

æKY PAT
æFr Types.r
æT
æD /*----------------------------PAT  • Quickdraw Pattern----------------------------------*/
type 'PAT ' {
        hex string[8];                                          /* Pattern              */
};
æC

æKY PAT#
æFr Types.r
æT
æD /*----------------------------PAT# • Quickdraw Pattern List-----------------------------*/
type 'PAT#' {
        integer = $$Countof(PatArray);
        array PatArray {
                hex string[8];                                  /* Pattern              */
        };
};
æC

æKY PICTtype
æFr Types.r
æT
æD #ifndef __PICT.R__
/*----------------------------PICT • Quickdraw Picture----------------------------------*/
type 'PICT' {
        unsigned integer;                                       /* Length               */
        rect;                                                   /* Frame                */
        hex string;                                             /* Data                 */
};
#endif __PICT.R__
æC

æKY pltt
æFr Types.r
æT
æD /*----------------------------pltt • Color Palette--------------------------------------*/
type 'pltt' {
        integer = $$CountOf(ColorInfo);                         /* Color table count    */
        fill long;                                              /* Reserved             */
        fill word;                                              /* Reserved             */
        fill long;                                              /* Reserved             */
        fill long;                                              /* Reserved             */
        wide array ColorInfo {
            unsigned integer;                                   /* RGB: red             */
            unsigned integer;                                   /*      green           */
            unsigned integer;                                   /*      blue            */
            integer     pmCourteous, pmDithered, pmTolerant,    /* Color usage          */
                        pmAnimated = 4, pmExplicit = 8;
            integer;                                            /* Tolerance value      */
            fill word;                                          /* Private flags        */
            fill long;                                          /* Private              */
        };
};
æC

æKY ppat
æFr Types.r
æT
æD #ifdef oldTemp
/*------------------------ppat • Pixel Pattern old template---------------------------------*/
    type 'ppat' {
            /* PixPat record */
            integer     oldPattern,                                 /* Pattern type         */
                        newPattern,
                        ditherPattern;
            unsigned longint = PixMap / 8;                          /* Offset to pixmap     */
            unsigned longint = PixelData / 8;                       /* Offset to data       */
            fill long;                                              /* Expanded pixel image */
            fill word;                                              /* Pattern valid flag   */
            fill long;                                              /* expanded pattern     */
            hex string [8];                                         /* old-style pattern    */

            /* PixMap record */
    PixMap:
            fill long;                                              /* Base address         */
            unsigned bitstring[1] = 1;                              /* New pixMap flag      */
            unsigned bitstring[2] = 0;                              /* Must be 0            */
            unsigned bitstring[13];                                 /* Offset to next row   */
            rect;                                                   /* Bitmap bounds        */
            integer;                                                /* pixMap vers number   */
            integer     unpacked;                                   /* Packing format       */
            unsigned longint;                                       /* size of pixel data   */
            unsigned hex longint;                                   /* h. resolution (ppi) (fixed) */
            unsigned hex longint;                                   /* v. resolution (ppi) (fixed) */
            integer         chunky, chunkyPlanar, planar;           /* Pixel storage format */
            integer;                                                /* # bits in pixel      */
            integer;                                                /* # components in pixel*/
            integer;                                                /* # bits per field     */
            unsigned longint;                                       /* Offset to next plane */
            unsigned longint = ColorTable / 8;                      /* Offset to color table*/
            fill long;                                              /* Reserved             */

    PixelData:
            hex string [(ColorTable - PixelData) / 8];

    ColorTable:
            unsigned hex longint;                                   /* ctSeed               */
            integer;                                                /* ctFlags              */
            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
            wide array ColorSpec {
                    integer;                                        /* value                */
                    unsigned integer;                               /* RGB: red             */
                    unsigned integer;                               /*      green           */
                    unsigned integer;                               /*      blue            */
            };
    };
#else
/*----------------------------ppat • Pixel Pattern--------------------------------------*/
    type 'ppat' {
            /* PixPat record */
            integer = 1 /* newPattern */;                           /* Pattern type         */
            unsigned longint = PixMap / 8;                          /* Offset to pixmap     */
            unsigned longint = PixelData / 8;                       /* Offset to data       */
            fill long;                                              /* Expanded pixel image */
            fill word;                                              /* Pattern valid flag   */
            fill long;                                              /* expanded pattern     */
            hex string [8];                                         /* old-style pattern    */

            /* PixMap record */
    PixMap:
            fill long;                                              /* Base address         */
            unsigned bitstring[1] = 1;                              /* New pixMap flag      */
            unsigned bitstring[2] = 0;                              /* Must be 0            */
pMapRowBytes:
            unsigned bitstring[13];                                 /* Offset to next row   */
    Bounds: rect;                                                   /* Bitmap bounds        */
            integer = 0;                                            /* pixMap vers number   */
            integer = 0;                                            /* Packing format       */
            fill long;                                              /* Size of pixel data   */
            unsigned hex longint = $00480000;                       /* h. resolution (ppi)  */
            unsigned hex longint = $00480000;                       /* v. resolution (ppi)  */
            integer = 0 /* chunky */;                               /* Pixel storage format */
    PixelSize:
            integer;                                                /* # bits in pixel      */
            integer = 1;                                            /* # components in pixel*/
            integer = $$Word(PixelSize);                            /* # bits per field     */
            fill long;
            unsigned longint = ColorTable / 8;
            fill long;

    PixelData:
            hex string [PixMapRowBytes * PixMapHeight];

    ColorTable:
            unsigned hex longint = 0;                               /* ctSeed               */
            integer = 0;                                            /* ctFlags              */
            integer = $$Countof(ColorSpec) - 1;                     /* ctSize               */
            wide array ColorSpec {
                    integer;                                        /* value                */
                    unsigned integer;                               /* RGB: red             */
                    unsigned integer;                               /*      green           */
                    unsigned integer;                               /*      blue            */
            };
    };
#endif
æC

æKY SICN
æFr Types.r
æT
æD /*----------------------------SICN • Small Icon-----------------------------------------*/
type 'SICN' {
        array {
                hex string[32];                                 /* SICN data            */
        };
};
æC

æKY ignoreAppDiedEvents
æFr Types.r
æT #define
æD #define ignoreAppDiedEvents          ignoreChildDiedEvents
æC

æKY acceptAppDiedEvents
æFr Types.r
æT #define
æD #define acceptAppDiedEvents          acceptChildDiedEvents
æC

æKY needsActivateOnFGSwitch
æFr Types.r
æT #define
æD #define needsActivateOnFGSwitch      notMultiFinderAware          /* for compatibility */
æC

æKY doesActivateOnFGSwitch
æFr Types.r
æT #define
æD #define doesActivateOnFGSwitch       multiFinderAware             /* for compatibility */
æC

æKY dontSaveScreen
æFr Types.r
æT #define
æD #define dontSaveScreen               reserved                     /* for compatibility */
æC

æKY saveScreen
æFr Types.r
æT #define
æD #define saveScreen                   true                         /* for compatibility */
æC

æKY enableOptionSwitch
æFr Types.r
æT #define
æD #define enableOptionSwitch           reserved                     /* for compatibility */
æC

æKY disableOptionSwitch
æFr Types.r
æT #define
æD #define disableOptionSwitch          true                         /* for compatibility */
æC

æKY SIZEtype
æFr Types.r
æT #define
æD
type 'SIZE' {
        boolean                 reserved;
        boolean                 ignoreSuspendResumeEvents,      /* suspend-resume       */
                                acceptSuspendResumeEvents;
        boolean                 reserved;
        boolean                 cannotBackground,
                                canBackground;                  /* Can properly use back-
                                                                   ground null events   */
        boolean                 needsActivateOnFGSwitch,        /* activate/deactivate  */
                                doesActivateOnFGSwitch;         /* on resume/suspend    */
        boolean                 backgroundAndForeground,        /* Application does not */
                                onlyBackground;                 /* have a user interface*/
        boolean                 dontGetFrontClicks,             /* Get mouse down/up    */
                                getFrontClicks;                 /* when suspended       */
        boolean                 ignoreAppDiedEvents,            /* Apps use this.       */
                                acceptAppDiedEvents;            /* Debuggers use this.  */
        boolean                 not32BitCompatible,             /* Works with 24bit addr*/
                                is32BitCompatible;              /* Works with 24 or 32  */
                                                                /* bit addresses        */
/* next four bits are new for system 7.0 */
        boolean                 notHighLevelEventAware,
                                isHighLevelEventAware;          /* does Post/AcceptHighLevelEvent */
        boolean                 onlyLocalHLEvents,              /* paranoid users' flag */
                                localAndRemoteHLEvents;
        boolean                 notStationeryAware,             /* checks stationery bit */
                                isStationeryAware;              /* when opening documents */
        boolean                 dontUseTextEditServices,        /* can use text services */
                                useTextEditServices;            /* through TextEdit.     */

#undef reserved
        boolean                 reserved;                       /* These 3 bits are     */
        boolean                 reserved;                       /* reserved.  Set them  */
        boolean                 reserved;                       /* to "reserved". When  */
                                                                /* we decide to define  */
                                                                /* a new flag, your     */
                                                                /* old resource will    */
                                                                /* still compile.       */

        /* Memory sizes are in bytes */
        unsigned longint;                                       /* preferred mem size   */
        unsigned longint;                                       /* minimum mem size     */

        // If we ever define one of the four reserved bits above, the "reserved"
        // enumeration wouldn't appear on the newly defined bit.  By defining "reserved"
        // below, old resource SIZE declarations will still compile.
#define reserved        false
};
æC

æKY STR
æFr Types.r
æT
æD /*----------------------------STR  • Pascal-Style String--------------------------------*/
type 'STR ' {
        pstring;                                                /* String               */
};
æC

æKY STR#
æFr Types.r
æT
æD /*----------------------------STR# • Pascal-Style String List---------------------------*/
type 'STR#' {
        integer = $$Countof(StringArray);
        array StringArray {
                pstring;                                        /* String               */
        };
};
æC

æKY wctb
æFr Types.r
æT
æD /*----------------------------wctb • Window Color Lookup Table--------------------------*/
type 'wctb' as 'actb';
æC

æKY WIND
æFr Types.r
æT
æD /*----------------------------WIND • Window Template------------------------------------*/
type 'WIND' {
        rect;                                                   /* boundsRect           */
        integer         documentProc,                           /* procID               */
                        dBoxProc,
                        plainDBox,
                        altDBoxProc,
                        noGrowDocProc,
                        movableDBoxProc,
                        zoomDocProc = 8,
                        zoomNoGrow = 12,
                        rDocProc = 16;
        byte            invisible, visible;                     /* visible              */
        fill byte;
        byte            noGoAway, goAway;                       /* goAway               */
        fill byte;
        unsigned hex longint;                                   /* refCon               */
        pstring         Untitled = "Untitled";                  /* title                */
    /*  The following are window positioning options ,usable in 7.0 */
#if SystemSevenOrLater
        align word;
        unsigned integer                noAutoCenter = 0x0000,
                                        centerMainScreen = 0x280a,
                                        alertPositionMainScreen = 0x300a,
                                        staggerMainScreen = 0x380a,
                                        centerParentWindow = 0xa80a,
                                        alertPositionParentWindow = 0xb00a,
                                        staggerParentWindow = 0xb80a,
                                        centerParentWindowScreen = 0x680a,
                                        alertPositionParentWindowScreen = 0x700a,
                                        staggerParentWindowScreen = 0x780a;
#endif
};
æC

æKY RECT
æFr Types.r
æT
æD /*--------------------------------------------------------------------------------------*/

/* resource containing a single rectangle */

    type 'RECT' { rect; };

æC

æKY silentStage
æFr Types.r
æT #define
æD #define silentStage OK, visible, silent
æC

æKY silentStages
æFr Types.r
æT #define
æD #define silentStages { silentStage; silentStage; silentStage; silentStage; }
æC

æKY beepStage
æFr Types.r
æT #define
æD #define beepStage OK, visible, sound1
æC

æKY beepStages
æFr Types.r
æT #define
æD #define beepStages { beepStage; beepStage; beepStage; beepStage; }
æC

æKY whiteRGB
æFr Types.r
æT #define
æD #define whiteRGB $FFFF, $FFFF, $FFFF
æC

æKY blackRGB
æFr Types.r
æT #define
æD #define blackRGB 0, 0, 0
æC

æKY transparentRGB
æFr Types.r
æT #define
æD #define transparentRGB $FFFF, $FFFF, $FFFF
æC

æKY invertRGB
æFr Types.r
æT #define
æD #define invertRGB 0, 0, 0
æC

æKY ics#
æFr Types.r
æT
æD
/* small icons with masks */

    type 'ics#' {
        array [2] {
            hex string[32];
        };
    };
    type 'kcs#' as 'ics#';                              /* Keyboard small icon <8> */

æC

æKY icm#
æFr Types.r
æT
æD /* mini icons with masks */

    type 'icm#' {
        array [2] {
            hex string[24];
        };
    };

æC

æKY icm8
æFr Types.r
æT
æD /* 8-bit color mini icon--no mask, no color table */

    type 'icm8' {
        hex string[192];
    };

æC

æKY icm4
æFr Types.r
æT
æD /* 4-bit color mini icon--no mask, no color table */

    type 'icm4' {
        hex string[96];
    };

æC

æKY icl8
æFr Types.r
æT
æD /* 8-bit color icon--no mask, no color table */

    type 'icl8' {
        hex string[1024];
    };
    type 'kcl8' as 'icl8';                              /* Keyboard 8-bit color icon <8> */

æC

æKY icl4
æFr Types.r
æT
æD /* 4-bit color icon--no mask, no color table */

    type 'icl4' {
        hex string[512];
    };
    type 'kcl4' as 'icl4';                              /* Keyboard 4-bit color icon <8> */

æC

æKY ics8
æFr Types.r
æT
æD /* 8-bit color small icon--no mask, no color table */

    type 'ics8' {
        hex string[256];
    };
    type 'kcs8' as 'ics8';                              /* Keyboard 8-bit small color icon <8> */

æC

æKY ics4
æFr Types.r
æT
æD /* 4-bit color small icon--no mask, no color table */

    type 'ics4' {
        hex string[128];
    };
    type 'kcs4' as 'ics4';                              /* Keyboard 4-bit small color icon <8> */

æC

æKY ppt#
æFr Types.r
æT
æD /* a list of pixpats; Rez can’t yet handle this correctly */

    type 'ppt#' {
            /* PixPat offsets (calculate them some day!?!) */
            integer = $$CountOf(OffsetArray);
            array OffsetArray /* [$$CountOf(PixPatArray)] */ {
                unsigned longint /* = PixPat[$$ArrayIndex(OffsetArray)] / 8 */;
            };

        array PixPatArray {
PixPat:
            /* PixPat record */
            integer = 1 /* newPattern */;                           /* Pattern type         */
            unsigned longint = PixMap[$$ArrayIndex(PixPatArray)] / 8;   /* Offset to pixmap     */
            unsigned longint = PixelData[$$ArrayIndex(PixPatArray)] / 8;    /* Offset to data       */
            fill long;                                              /* Expanded pixel image */
            fill word;                                              /* Pattern valid flag   */
            fill long;                                              /* expanded pattern     */
            hex string [8];                                         /* old-style pattern    */

            /* PixMap record */
PixMap:
            fill long;                                              /* Base address         */
            unsigned bitstring[1] = 1;                              /* New pixMap flag      */
            unsigned bitstring[2] = 0;                              /* Must be 0            */
pMapRowBytesIndexed:
            unsigned bitstring[13];         /* Offset to next row   */
Bounds:     rect;                                                   /* Bitmap bounds        */
            integer = 0;                                            /* pixMap vers number   */
            integer = 0;                                            /* Packing format       */
            fill long;                                              /* Size of pixel data   */
            unsigned hex longint = $00480000;                       /* h. resolution (ppi)  */
            unsigned hex longint = $00480000;                       /* v. resolution (ppi)  */
            integer = 0 /* chunky */;                               /* Pixel storage format */
PixelSize:
            integer;                                                /* # bits in pixel      */
            integer = 1;                                            /* # components in pixel*/
            integer = $$Word(PixelSize[$$ArrayIndex(PixPatArray)]); /* # bits per field     */
            fill long;
            unsigned longint = ColorTable[$$ArrayIndex(PixPatArray)] / 8;
            fill long;

PixelData:
            hex string [PixMapRowBytesIndexed * PixMapHeightIndexed];

ColorTable:
            unsigned hex longint = 0;                               /* ctSeed               */
            integer = 0;                                            /* ctFlags              */
            integer = $$Countof(ColorSpec[$$ArrayIndex(PixPatArray)]) - 1;                      /* ctSize               */
            wide array ColorSpec {
                    integer = $$ArrayIndex(ColorSpec[$$ArrayIndex(PixPatArray)]) - 1;           /* value                */
                    unsigned integer;                               /* RGB: red             */
                    unsigned integer;                               /*      green           */
                    unsigned integer;                               /*      blue            */
            };
        };
    };

æC

æKY wstr
æFr Types.r
æT
æD /* types for the Database Access Manager */

/* 'wstr' - Word Length String Resource */
type 'wstr' {
        wstring;                                                /* string with word length spec. */
};
æC

æKY qrsc
æFr Types.r
æT
æD /* 'qrsc' - Query Resource */
type 'qrsc' {
        integer;                                                /* version */

        integer;                                                /* 'qdef' ID */

        integer;                                                /* STR# ID for ddevName, host,
                                                                     user, password, connstr */

        integer;                                                /* current query */

        /* array of IDs of 'wstr' resources containing queries */
        integer = $$CountOf(QueryArray);                        /* array size */
        wide array QueryArray {
            integer;                                            /* id of 'wstr' resource */
        };

        /* array of types and IDs for other resources for query */
        integer = $$CountOf(ResArray);                          /* array size */
        wide array ResArray {
            literal longint;                                    /* resource type */
            integer;                                            /* resource ID */
        };
};
æC

æKY dflg
æFr Types.r
æT
æD /* 'dflg' - ddev Flags */
type 'dflg' {
        longint;                                                /* version */

        unsigned bitstring[32]                                  /* ddev flags */
            asyncNotSupp, asyncSupp;
};

/*--------------------------------------------------------------------------------------*/


#endif __TYPES.R__